
// Copyright (C) 2009-2011 Luca Piccioni
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;

#pragma warning disable 1572, 1573

namespace Derm.OpenGL {

	/// <summary>
	/// Implementation of the OpenGL specification 
	/// </summary>
	public unsafe partial class Gl : ProcLoader
	{

		/// <summary>
		/// Binding for glAlphaFragmentOp1ATI function.
		/// </summary>
		/// <param name="op">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="dst">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="dstMod">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg1">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg1Rep">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg1Mod">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void AlphaFragmentOp1ATI(int op, UInt32 dst, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod) {
			if      (Delegates.pglAlphaFragmentOp1ATI != null)
				Delegates.pglAlphaFragmentOp1ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod);
			else
				throw new InvalidOperationException("binding point AlphaFragmentOp1ATI cannot be found");
			LogProc("glAlphaFragmentOp1ATI({0}, {1}, {2}, {3}, {4}, {5})", op, dst, dstMod, arg1, arg1Rep, arg1Mod);
		}

		/// <summary>
		/// Binding for glAlphaFragmentOp2ATI function.
		/// </summary>
		/// <param name="op">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="dst">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="dstMod">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg1">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg1Rep">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg1Mod">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg2">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg2Rep">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg2Mod">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void AlphaFragmentOp2ATI(int op, UInt32 dst, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod, UInt32 arg2, UInt32 arg2Rep, UInt32 arg2Mod) {
			if      (Delegates.pglAlphaFragmentOp2ATI != null)
				Delegates.pglAlphaFragmentOp2ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);
			else
				throw new InvalidOperationException("binding point AlphaFragmentOp2ATI cannot be found");
			LogProc("glAlphaFragmentOp2ATI({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8})", op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);
		}

		/// <summary>
		/// Binding for glAlphaFragmentOp3ATI function.
		/// </summary>
		/// <param name="op">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="dst">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="dstMod">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg1">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg1Rep">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg1Mod">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg2">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg2Rep">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg2Mod">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg3">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg3Rep">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg3Mod">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void AlphaFragmentOp3ATI(int op, UInt32 dst, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod, UInt32 arg2, UInt32 arg2Rep, UInt32 arg2Mod, UInt32 arg3, UInt32 arg3Rep, UInt32 arg3Mod) {
			if      (Delegates.pglAlphaFragmentOp3ATI != null)
				Delegates.pglAlphaFragmentOp3ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);
			else
				throw new InvalidOperationException("binding point AlphaFragmentOp3ATI cannot be found");
			LogProc("glAlphaFragmentOp3ATI({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11})", op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);
		}

		/// <summary>
		/// Binding for glArrayObjectATI function.
		/// </summary>
		/// <param name="array">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="size">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="type">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="stride">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="buffer">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="offset">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void ArrayObjectATI(int array, int size, int type, Int32 stride, UInt32 buffer, UInt32 offset) {
			if      (Delegates.pglArrayObjectATI != null)
				Delegates.pglArrayObjectATI(array, size, type, stride, buffer, offset);
			else
				throw new InvalidOperationException("binding point ArrayObjectATI cannot be found");
			LogProc("glArrayObjectATI({0}, {1}, {2}, {3}, {4}, {5})", array, size, type, stride, buffer, offset);
		}

		/// <summary>
		/// Binding for glBeginFragmentShaderATI function.
		/// </summary>
		/// @note This routine is available from OpenGL 1.2
		public static void BeginFragmentShaderATI() {
			if      (Delegates.pglBeginFragmentShaderATI != null)
				Delegates.pglBeginFragmentShaderATI();
			else
				throw new InvalidOperationException("binding point BeginFragmentShaderATI cannot be found");
			LogProc("glBeginFragmentShaderATI()");
		}

		/// <summary>
		/// Binding for glBindFragmentShaderATI function.
		/// </summary>
		/// <param name="id">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void BindFragmentShaderATI(UInt32 id) {
			if      (Delegates.pglBindFragmentShaderATI != null)
				Delegates.pglBindFragmentShaderATI(id);
			else
				throw new InvalidOperationException("binding point BindFragmentShaderATI cannot be found");
			LogProc("glBindFragmentShaderATI({0})", id);
		}

		/// <summary>
		/// Binding for glBlendEquationIndexedAMD function.
		/// </summary>
		/// <param name="buf">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="mode">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 2.0
		public static void BlendEquationIndexedAMD(UInt32 buf, int mode) {
			if      (Delegates.pglBlendEquationIndexedAMD != null)
				Delegates.pglBlendEquationIndexedAMD(buf, mode);
			else
				throw new InvalidOperationException("binding point BlendEquationIndexedAMD cannot be found");
			LogProc("glBlendEquationIndexedAMD({0}, {1})", buf, mode);
		}

		/// <summary>
		/// Binding for glBlendEquationSeparateIndexedAMD function.
		/// </summary>
		/// <param name="buf">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="modeRGB">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="modeAlpha">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 2.0
		public static void BlendEquationSeparateIndexedAMD(UInt32 buf, int modeRGB, int modeAlpha) {
			if      (Delegates.pglBlendEquationSeparateIndexedAMD != null)
				Delegates.pglBlendEquationSeparateIndexedAMD(buf, modeRGB, modeAlpha);
			else
				throw new InvalidOperationException("binding point BlendEquationSeparateIndexedAMD cannot be found");
			LogProc("glBlendEquationSeparateIndexedAMD({0}, {1}, {2})", buf, modeRGB, modeAlpha);
		}

		/// <summary>
		/// Binding for glBlendFuncIndexedAMD function.
		/// </summary>
		/// <param name="buf">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="src">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="dst">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 2.0
		public static void BlendFuncIndexedAMD(UInt32 buf, int src, int dst) {
			if      (Delegates.pglBlendFuncIndexedAMD != null)
				Delegates.pglBlendFuncIndexedAMD(buf, src, dst);
			else
				throw new InvalidOperationException("binding point BlendFuncIndexedAMD cannot be found");
			LogProc("glBlendFuncIndexedAMD({0}, {1}, {2})", buf, src, dst);
		}

		/// <summary>
		/// Binding for glBlendFuncSeparateIndexedAMD function.
		/// </summary>
		/// <param name="buf">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="srcRGB">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="dstRGB">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="srcAlpha">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="dstAlpha">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 2.0
		public static void BlendFuncSeparateIndexedAMD(UInt32 buf, int srcRGB, int dstRGB, int srcAlpha, int dstAlpha) {
			if      (Delegates.pglBlendFuncSeparateIndexedAMD != null)
				Delegates.pglBlendFuncSeparateIndexedAMD(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
			else
				throw new InvalidOperationException("binding point BlendFuncSeparateIndexedAMD cannot be found");
			LogProc("glBlendFuncSeparateIndexedAMD({0}, {1}, {2}, {3}, {4})", buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
		}

		/// <summary>
		/// Binding for glClientActiveVertexStreamATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void ClientActiveVertexStreamATI(int stream) {
			if      (Delegates.pglClientActiveVertexStreamATI != null)
				Delegates.pglClientActiveVertexStreamATI(stream);
			else
				throw new InvalidOperationException("binding point ClientActiveVertexStreamATI cannot be found");
			LogProc("glClientActiveVertexStreamATI({0})", stream);
		}

		/// <summary>
		/// Binding for glColorFragmentOp1ATI function.
		/// </summary>
		/// <param name="op">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="dst">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="dstMask">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="dstMod">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg1">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg1Rep">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg1Mod">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void ColorFragmentOp1ATI(int op, UInt32 dst, UInt32 dstMask, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod) {
			if      (Delegates.pglColorFragmentOp1ATI != null)
				Delegates.pglColorFragmentOp1ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod);
			else
				throw new InvalidOperationException("binding point ColorFragmentOp1ATI cannot be found");
			LogProc("glColorFragmentOp1ATI({0}, {1}, {2}, {3}, {4}, {5}, {6})", op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod);
		}

		/// <summary>
		/// Binding for glColorFragmentOp2ATI function.
		/// </summary>
		/// <param name="op">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="dst">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="dstMask">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="dstMod">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg1">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg1Rep">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg1Mod">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg2">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg2Rep">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg2Mod">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void ColorFragmentOp2ATI(int op, UInt32 dst, UInt32 dstMask, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod, UInt32 arg2, UInt32 arg2Rep, UInt32 arg2Mod) {
			if      (Delegates.pglColorFragmentOp2ATI != null)
				Delegates.pglColorFragmentOp2ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);
			else
				throw new InvalidOperationException("binding point ColorFragmentOp2ATI cannot be found");
			LogProc("glColorFragmentOp2ATI({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9})", op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);
		}

		/// <summary>
		/// Binding for glColorFragmentOp3ATI function.
		/// </summary>
		/// <param name="op">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="dst">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="dstMask">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="dstMod">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg1">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg1Rep">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg1Mod">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg2">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg2Rep">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg2Mod">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg3">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg3Rep">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="arg3Mod">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void ColorFragmentOp3ATI(int op, UInt32 dst, UInt32 dstMask, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod, UInt32 arg2, UInt32 arg2Rep, UInt32 arg2Mod, UInt32 arg3, UInt32 arg3Rep, UInt32 arg3Mod) {
			if      (Delegates.pglColorFragmentOp3ATI != null)
				Delegates.pglColorFragmentOp3ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);
			else
				throw new InvalidOperationException("binding point ColorFragmentOp3ATI cannot be found");
			LogProc("glColorFragmentOp3ATI({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11}, {12})", op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);
		}

		/// <summary>
		/// Binding for glDeleteFragmentShaderATI function.
		/// </summary>
		/// <param name="id">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void DeleteFragmentShaderATI(UInt32 id) {
			if      (Delegates.pglDeleteFragmentShaderATI != null)
				Delegates.pglDeleteFragmentShaderATI(id);
			else
				throw new InvalidOperationException("binding point DeleteFragmentShaderATI cannot be found");
			LogProc("glDeleteFragmentShaderATI({0})", id);
		}

		/// <summary>
		/// Binding for glDeleteNamesAMD function.
		/// </summary>
		/// <param name="identifier">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="num">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="names">
		/// A <see cref="T:System.UInt32*"/>.
		/// </param>
		/// @note This routine is available from OpenGL 4.1
		public static void DeleteNameAMD(int identifier, UInt32 num, UInt32[] names) {
			unsafe {
				fixed (UInt32* fp_names = names)
				{
					if      (Delegates.pglDeleteNamesAMD != null)
						Delegates.pglDeleteNamesAMD(identifier, num, fp_names);
					else
						throw new InvalidOperationException("binding point DeleteNameAMD cannot be found");
				}
			}
			LogProc("glDeleteNamesAMD({0}, {1}, {2})", identifier, num, names);
		}

		/// <summary>
		/// Binding for glDeleteNamesAMD function.
		/// </summary>
		/// <param name="identifier">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="num">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="names">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 4.1
		public static void DeleteNameAMD(int identifier, UInt32 num, UInt32* names) {
			unsafe {
				if      (Delegates.pglDeleteNamesAMD != null)
					Delegates.pglDeleteNamesAMD(identifier, num, names);
				else
					throw new InvalidOperationException("binding point DeleteNameAMD cannot be found");
			}
			LogProc("glDeleteNamesAMD({0}, {1}, {2})", identifier, num, "names");
		}
		

		/// <summary>
		/// Binding for glDrawBuffersATI function.
		/// </summary>
		/// <param name="n">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="bufs">
		/// A <see cref="T:System.Int32*"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void DrawBuffersATI(Int32 n, int[] bufs) {
			unsafe {
				fixed (int* fp_bufs = bufs)
				{
					if      (Delegates.pglDrawBuffersATI != null)
						Delegates.pglDrawBuffersATI(n, fp_bufs);
					else
						throw new InvalidOperationException("binding point DrawBuffersATI cannot be found");
				}
			}
			LogProc("glDrawBuffersATI({0}, {1})", n, bufs);
		}

		/// <summary>
		/// Binding for glDrawElementArrayATI function.
		/// </summary>
		/// <param name="mode">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="count">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void DrawElementArrayATI(int mode, Int32 count) {
			if      (Delegates.pglDrawElementArrayATI != null)
				Delegates.pglDrawElementArrayATI(mode, count);
			else
				throw new InvalidOperationException("binding point DrawElementArrayATI cannot be found");
			LogProc("glDrawElementArrayATI({0}, {1})", mode, count);
		}

		/// <summary>
		/// Binding for glDrawRangeElementArrayATI function.
		/// </summary>
		/// <param name="mode">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="start">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="end">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="count">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void DrawRangeElementArrayATI(int mode, UInt32 start, UInt32 end, Int32 count) {
			if      (Delegates.pglDrawRangeElementArrayATI != null)
				Delegates.pglDrawRangeElementArrayATI(mode, start, end, count);
			else
				throw new InvalidOperationException("binding point DrawRangeElementArrayATI cannot be found");
			LogProc("glDrawRangeElementArrayATI({0}, {1}, {2}, {3})", mode, start, end, count);
		}

		/// <summary>
		/// Binding for glElementPointerATI function.
		/// </summary>
		/// <param name="type">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="pointer">
		/// A <see cref="T:System.IntPtr"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void ElementPointerATI(int type, object pointer) {
			GCHandle pp_pointer = GCHandle.Alloc(pointer, GCHandleType.Pinned);
			try {
				if      (Delegates.pglElementPointerATI != null)
					Delegates.pglElementPointerATI(type, pp_pointer.AddrOfPinnedObject());
				else
					throw new InvalidOperationException("binding point ElementPointerATI cannot be found");
			} finally {
				pp_pointer.Free();
			}
			LogProc("glElementPointerATI({0}, {1})", type, pointer);
		}

		/// <summary>
		/// Binding for glEndFragmentShaderATI function.
		/// </summary>
		/// @note This routine is available from OpenGL 1.2
		public static void EndFragmentShaderATI() {
			if      (Delegates.pglEndFragmentShaderATI != null)
				Delegates.pglEndFragmentShaderATI();
			else
				throw new InvalidOperationException("binding point EndFragmentShaderATI cannot be found");
			LogProc("glEndFragmentShaderATI()");
		}

		/// <summary>
		/// Binding for glFreeObjectBufferATI function.
		/// </summary>
		/// <param name="buffer">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void FreeObjectBufferATI(UInt32 buffer) {
			if      (Delegates.pglFreeObjectBufferATI != null)
				Delegates.pglFreeObjectBufferATI(buffer);
			else
				throw new InvalidOperationException("binding point FreeObjectBufferATI cannot be found");
			LogProc("glFreeObjectBufferATI({0})", buffer);
		}

		/// <summary>
		/// Binding for glGenFragmentShadersATI function.
		/// </summary>
		/// <param name="range">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static UInt32 GenFragmentShadersATI(UInt32 range) {
			UInt32 retvalue;
			if      (Delegates.pglGenFragmentShadersATI != null)
				retvalue = (Delegates.pglGenFragmentShadersATI(range));
			else
				throw new InvalidOperationException("binding point GenFragmentShadersATI cannot be found");
			LogProc("glGenFragmentShadersATI({0}) = {1}", range, retvalue);
			return (retvalue);
		}

		/// <summary>
		/// Binding for glGenNamesAMD function.
		/// </summary>
		/// <param name="identifier">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="num">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="names">
		/// A <see cref="T:System.UInt32*"/>.
		/// This parameter holds data returned from function.
		/// </param>
		/// @note This routine is available from OpenGL 4.1
		public static void GenNameAMD(int identifier, UInt32 num, [Out] UInt32[] names) {
			unsafe {
				fixed (UInt32* fp_names = names)
				{
					if      (Delegates.pglGenNamesAMD != null)
						Delegates.pglGenNamesAMD(identifier, num, fp_names);
					else
						throw new InvalidOperationException("binding point GenNameAMD cannot be found");
				}
			}
			LogProc("glGenNamesAMD({0}, {1}, {2})", identifier, num, names);
		}

		/// <summary>
		/// Binding for glGenNamesAMD function.
		/// </summary>
		/// <param name="identifier">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="num">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="names">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 4.1
		public static void GenNameAMD(int identifier, UInt32 num, UInt32* names) {
			unsafe {
				if      (Delegates.pglGenNamesAMD != null)
					Delegates.pglGenNamesAMD(identifier, num, names);
				else
					throw new InvalidOperationException("binding point GenNameAMD cannot be found");
			}
			LogProc("glGenNamesAMD({0}, {1}, {2})", identifier, num, "names");
		}
		

		/// <summary>
		/// Binding for glGetArrayObjectfvATI function.
		/// </summary>
		/// <param name="array">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="pname">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="params">
		/// A <see cref="T:System.Single"/>.
		/// This parameter holds data returned from function.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void GetArrayObjectATI(int array, int pname, [Out] out float @params) {
			unsafe {
				fixed (float* fp_params = &@params)
				{
					if      (Delegates.pglGetArrayObjectfvATI != null)
						Delegates.pglGetArrayObjectfvATI(array, pname, fp_params);
					else
						throw new InvalidOperationException("binding point GetArrayObjectATI cannot be found");
				}
			}
			LogProc("glGetArrayObjectfvATI({0}, {1}, {2})", array, pname, @params);
		}

		/// <summary>
		/// Binding for glGetArrayObjectivATI function.
		/// </summary>
		/// <param name="array">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="pname">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="params">
		/// A <see cref="T:System.Int32"/>.
		/// This parameter holds data returned from function.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void GetArrayObjectATI(int array, int pname, [Out] out int @params) {
			unsafe {
				fixed (int* fp_params = &@params)
				{
					if      (Delegates.pglGetArrayObjectivATI != null)
						Delegates.pglGetArrayObjectivATI(array, pname, fp_params);
					else
						throw new InvalidOperationException("binding point GetArrayObjectATI cannot be found");
				}
			}
			LogProc("glGetArrayObjectivATI({0}, {1}, {2})", array, pname, @params);
		}

		/// <summary>
		/// Binding for glGetObjectBufferfvATI function.
		/// </summary>
		/// <param name="buffer">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="pname">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="params">
		/// A <see cref="T:System.Single"/>.
		/// This parameter holds data returned from function.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void GetObjectBufferATI(UInt32 buffer, int pname, [Out] out float @params) {
			unsafe {
				fixed (float* fp_params = &@params)
				{
					if      (Delegates.pglGetObjectBufferfvATI != null)
						Delegates.pglGetObjectBufferfvATI(buffer, pname, fp_params);
					else
						throw new InvalidOperationException("binding point GetObjectBufferATI cannot be found");
				}
			}
			LogProc("glGetObjectBufferfvATI({0}, {1}, {2})", buffer, pname, @params);
		}

		/// <summary>
		/// Binding for glGetObjectBufferivATI function.
		/// </summary>
		/// <param name="buffer">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="pname">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="params">
		/// A <see cref="T:System.Int32"/>.
		/// This parameter holds data returned from function.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void GetObjectBufferATI(UInt32 buffer, int pname, [Out] out int @params) {
			unsafe {
				fixed (int* fp_params = &@params)
				{
					if      (Delegates.pglGetObjectBufferivATI != null)
						Delegates.pglGetObjectBufferivATI(buffer, pname, fp_params);
					else
						throw new InvalidOperationException("binding point GetObjectBufferATI cannot be found");
				}
			}
			LogProc("glGetObjectBufferivATI({0}, {1}, {2})", buffer, pname, @params);
		}

		/// <summary>
		/// Binding for glGetTexBumpParameterfvATI function.
		/// </summary>
		/// <param name="pname">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="param">
		/// A <see cref="T:System.Single*"/>.
		/// This parameter holds data returned from function.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void GetTexBumpParameterATI(int pname, [Out] float[] param) {
			unsafe {
				fixed (float* fp_param = param)
				{
					if      (Delegates.pglGetTexBumpParameterfvATI != null)
						Delegates.pglGetTexBumpParameterfvATI(pname, fp_param);
					else
						throw new InvalidOperationException("binding point GetTexBumpParameterATI cannot be found");
				}
			}
			LogProc("glGetTexBumpParameterfvATI({0}, {1})", pname, param);
		}

		/// <summary>
		/// Binding for glGetTexBumpParameterfvATI function.
		/// </summary>
		/// <param name="pname">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="param">
		/// A <see cref="T:System.Single"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void GetTexBumpParameterATI(int pname, float* param) {
			unsafe {
				if      (Delegates.pglGetTexBumpParameterfvATI != null)
					Delegates.pglGetTexBumpParameterfvATI(pname, param);
				else
					throw new InvalidOperationException("binding point GetTexBumpParameterATI cannot be found");
			}
			LogProc("glGetTexBumpParameterfvATI({0}, {1})", pname, "param");
		}
		

		/// <summary>
		/// Binding for glGetTexBumpParameterivATI function.
		/// </summary>
		/// <param name="pname">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="param">
		/// A <see cref="T:System.Int32*"/>.
		/// This parameter holds data returned from function.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void GetTexBumpParameterATI(int pname, [Out] int[] param) {
			unsafe {
				fixed (int* fp_param = param)
				{
					if      (Delegates.pglGetTexBumpParameterivATI != null)
						Delegates.pglGetTexBumpParameterivATI(pname, fp_param);
					else
						throw new InvalidOperationException("binding point GetTexBumpParameterATI cannot be found");
				}
			}
			LogProc("glGetTexBumpParameterivATI({0}, {1})", pname, param);
		}

		/// <summary>
		/// Binding for glGetTexBumpParameterivATI function.
		/// </summary>
		/// <param name="pname">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="param">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void GetTexBumpParameterATI(int pname, int* param) {
			unsafe {
				if      (Delegates.pglGetTexBumpParameterivATI != null)
					Delegates.pglGetTexBumpParameterivATI(pname, param);
				else
					throw new InvalidOperationException("binding point GetTexBumpParameterATI cannot be found");
			}
			LogProc("glGetTexBumpParameterivATI({0}, {1})", pname, "param");
		}
		

		/// <summary>
		/// Binding for glGetVariantArrayObjectfvATI function.
		/// </summary>
		/// <param name="id">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="pname">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="params">
		/// A <see cref="T:System.Single"/>.
		/// This parameter holds data returned from function.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void GetVariantArrayObjectATI(UInt32 id, int pname, [Out] out float @params) {
			unsafe {
				fixed (float* fp_params = &@params)
				{
					if      (Delegates.pglGetVariantArrayObjectfvATI != null)
						Delegates.pglGetVariantArrayObjectfvATI(id, pname, fp_params);
					else
						throw new InvalidOperationException("binding point GetVariantArrayObjectATI cannot be found");
				}
			}
			LogProc("glGetVariantArrayObjectfvATI({0}, {1}, {2})", id, pname, @params);
		}

		/// <summary>
		/// Binding for glGetVariantArrayObjectivATI function.
		/// </summary>
		/// <param name="id">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="pname">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="params">
		/// A <see cref="T:System.Int32"/>.
		/// This parameter holds data returned from function.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void GetVariantArrayObjectATI(UInt32 id, int pname, [Out] out int @params) {
			unsafe {
				fixed (int* fp_params = &@params)
				{
					if      (Delegates.pglGetVariantArrayObjectivATI != null)
						Delegates.pglGetVariantArrayObjectivATI(id, pname, fp_params);
					else
						throw new InvalidOperationException("binding point GetVariantArrayObjectATI cannot be found");
				}
			}
			LogProc("glGetVariantArrayObjectivATI({0}, {1}, {2})", id, pname, @params);
		}

		/// <summary>
		/// Binding for glGetVertexAttribArrayObjectfvATI function.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="pname">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="params">
		/// A <see cref="T:System.Single*"/>.
		/// This parameter holds data returned from function.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void GetVertexAttribArrayObjectATI(UInt32 index, int pname, [Out] float[] @params) {
			unsafe {
				fixed (float* fp_params = @params)
				{
					if      (Delegates.pglGetVertexAttribArrayObjectfvATI != null)
						Delegates.pglGetVertexAttribArrayObjectfvATI(index, pname, fp_params);
					else
						throw new InvalidOperationException("binding point GetVertexAttribArrayObjectATI cannot be found");
				}
			}
			LogProc("glGetVertexAttribArrayObjectfvATI({0}, {1}, {2})", index, pname, @params);
		}

		/// <summary>
		/// Binding for glGetVertexAttribArrayObjectfvATI function.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="pname">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="params">
		/// A <see cref="T:System.Single"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void GetVertexAttribArrayObjectATI(UInt32 index, int pname, float* @params) {
			unsafe {
				if      (Delegates.pglGetVertexAttribArrayObjectfvATI != null)
					Delegates.pglGetVertexAttribArrayObjectfvATI(index, pname, @params);
				else
					throw new InvalidOperationException("binding point GetVertexAttribArrayObjectATI cannot be found");
			}
			LogProc("glGetVertexAttribArrayObjectfvATI({0}, {1}, {2})", index, pname, "@params");
		}
		

		/// <summary>
		/// Binding for glGetVertexAttribArrayObjectivATI function.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="pname">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="params">
		/// A <see cref="T:System.Int32*"/>.
		/// This parameter holds data returned from function.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void GetVertexAttribArrayObjectATI(UInt32 index, int pname, [Out] int[] @params) {
			unsafe {
				fixed (int* fp_params = @params)
				{
					if      (Delegates.pglGetVertexAttribArrayObjectivATI != null)
						Delegates.pglGetVertexAttribArrayObjectivATI(index, pname, fp_params);
					else
						throw new InvalidOperationException("binding point GetVertexAttribArrayObjectATI cannot be found");
				}
			}
			LogProc("glGetVertexAttribArrayObjectivATI({0}, {1}, {2})", index, pname, @params);
		}

		/// <summary>
		/// Binding for glGetVertexAttribArrayObjectivATI function.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="pname">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="params">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void GetVertexAttribArrayObjectATI(UInt32 index, int pname, int* @params) {
			unsafe {
				if      (Delegates.pglGetVertexAttribArrayObjectivATI != null)
					Delegates.pglGetVertexAttribArrayObjectivATI(index, pname, @params);
				else
					throw new InvalidOperationException("binding point GetVertexAttribArrayObjectATI cannot be found");
			}
			LogProc("glGetVertexAttribArrayObjectivATI({0}, {1}, {2})", index, pname, "@params");
		}
		

		/// <summary>
		/// Binding for glIsNameAMD function.
		/// </summary>
		/// <param name="identifier">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="name">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 4.1
		public static bool IsNameAMD(int identifier, UInt32 name) {
			bool retvalue;
			if      (Delegates.pglIsNameAMD != null)
				retvalue = (Delegates.pglIsNameAMD(identifier, name));
			else
				throw new InvalidOperationException("binding point IsNameAMD cannot be found");
			LogProc("glIsNameAMD({0}, {1}) = {2}", identifier, name, retvalue);
			return (retvalue);
		}

		/// <summary>
		/// Binding for glIsObjectBufferATI function.
		/// </summary>
		/// <param name="buffer">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static bool IsObjectBufferATI(UInt32 buffer) {
			bool retvalue;
			if      (Delegates.pglIsObjectBufferATI != null)
				retvalue = (Delegates.pglIsObjectBufferATI(buffer));
			else
				throw new InvalidOperationException("binding point IsObjectBufferATI cannot be found");
			LogProc("glIsObjectBufferATI({0}) = {1}", buffer, retvalue);
			return (retvalue);
		}

		/// <summary>
		/// Binding for glMapObjectBufferATI function.
		/// </summary>
		/// <param name="buffer">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static IntPtr MapObjectBufferATI(UInt32 buffer) {
			IntPtr retvalue;
			if      (Delegates.pglMapObjectBufferATI != null)
				retvalue = (Delegates.pglMapObjectBufferATI(buffer));
			else
				throw new InvalidOperationException("binding point MapObjectBufferATI cannot be found");
			LogProc("glMapObjectBufferATI({0}) = {1}", buffer, retvalue);
			return (retvalue);
		}

		/// <summary>
		/// Binding for glMultiDrawArraysIndirectAMD function.
		/// </summary>
		/// <param name="mode">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="indirect">
		/// A <see cref="T:System.IntPtr"/>.
		/// </param>
		/// <param name="primcount">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="stride">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 4.0
		public static void MultiDrawArraysIndirectAMD(int mode, object indirect, Int32 primcount, Int32 stride) {
			GCHandle pp_indirect = GCHandle.Alloc(indirect, GCHandleType.Pinned);
			try {
				if      (Delegates.pglMultiDrawArraysIndirectAMD != null)
					Delegates.pglMultiDrawArraysIndirectAMD(mode, pp_indirect.AddrOfPinnedObject(), primcount, stride);
				else
					throw new InvalidOperationException("binding point MultiDrawArraysIndirectAMD cannot be found");
			} finally {
				pp_indirect.Free();
			}
			LogProc("glMultiDrawArraysIndirectAMD({0}, {1}, {2}, {3})", mode, indirect, primcount, stride);
		}

		/// <summary>
		/// Binding for glMultiDrawElementsIndirectAMD function.
		/// </summary>
		/// <param name="mode">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="type">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="indirect">
		/// A <see cref="T:System.IntPtr"/>.
		/// </param>
		/// <param name="primcount">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="stride">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 4.0
		public static void MultiDrawElementsIndirectAMD(int mode, int type, object indirect, Int32 primcount, Int32 stride) {
			GCHandle pp_indirect = GCHandle.Alloc(indirect, GCHandleType.Pinned);
			try {
				if      (Delegates.pglMultiDrawElementsIndirectAMD != null)
					Delegates.pglMultiDrawElementsIndirectAMD(mode, type, pp_indirect.AddrOfPinnedObject(), primcount, stride);
				else
					throw new InvalidOperationException("binding point MultiDrawElementsIndirectAMD cannot be found");
			} finally {
				pp_indirect.Free();
			}
			LogProc("glMultiDrawElementsIndirectAMD({0}, {1}, {2}, {3}, {4})", mode, type, indirect, primcount, stride);
		}

		/// <summary>
		/// Binding for glNewObjectBufferATI function.
		/// </summary>
		/// <param name="size">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="pointer">
		/// A <see cref="T:System.IntPtr"/>.
		/// </param>
		/// <param name="usage">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static UInt32 NewObjectBufferATI(Int32 size, object pointer, int usage) {
			UInt32 retvalue;
			GCHandle pp_pointer = GCHandle.Alloc(pointer, GCHandleType.Pinned);
			try {
				if      (Delegates.pglNewObjectBufferATI != null)
					retvalue = (Delegates.pglNewObjectBufferATI(size, pp_pointer.AddrOfPinnedObject(), usage));
				else
					throw new InvalidOperationException("binding point NewObjectBufferATI cannot be found");
			} finally {
				pp_pointer.Free();
			}
			LogProc("glNewObjectBufferATI({0}, {1}, {2}) = {3}", size, pointer, usage, retvalue);
			return (retvalue);
		}

		/// <summary>
		/// Binding for glNewObjectBufferATI function.
		/// </summary>
		/// <param name="size">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="pointer">
		/// A <see cref="T:System.Void"/>.
		/// </param>
		/// <param name="usage">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static UInt32 NewObjectBufferATI(Int32 size, IntPtr pointer, int usage) {
			UInt32 retvalue;
			unsafe {
				if      (Delegates.pglNewObjectBufferATI != null)
					retvalue = (Delegates.pglNewObjectBufferATI(size, new IntPtr((long)pointer), usage));
				else
					throw new InvalidOperationException("binding point NewObjectBufferATI cannot be found");
			}
			LogProc("glNewObjectBufferATI({0}, {1}, {2}) = {3}", size, "pointer", usage, retvalue);
			return (retvalue);
		}
		

		/// <summary>
		/// Binding for glNormalStream3bATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="nx">
		/// A <see cref="T:System.SByte"/>.
		/// </param>
		/// <param name="ny">
		/// A <see cref="T:System.SByte"/>.
		/// </param>
		/// <param name="nz">
		/// A <see cref="T:System.SByte"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void NormalStream3ATI(int stream, sbyte nx, sbyte ny, sbyte nz) {
			if      (Delegates.pglNormalStream3bATI != null)
				Delegates.pglNormalStream3bATI(stream, nx, ny, nz);
			else
				throw new InvalidOperationException("binding point NormalStream3ATI cannot be found");
			LogProc("glNormalStream3bATI({0}, {1}, {2}, {3})", stream, nx, ny, nz);
		}

		/// <summary>
		/// Binding for glNormalStream3bvATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.SByte*"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void NormalStream3ATI(int stream, sbyte[] coords) {
			unsafe {
				fixed (sbyte* fp_coords = coords)
				{
					if      (Delegates.pglNormalStream3bvATI != null)
						Delegates.pglNormalStream3bvATI(stream, fp_coords);
					else
						throw new InvalidOperationException("binding point NormalStream3ATI cannot be found");
				}
			}
			LogProc("glNormalStream3bvATI({0}, {1})", stream, coords);
		}

		/// <summary>
		/// Binding for glNormalStream3dATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="nx">
		/// A <see cref="T:System.Double"/>.
		/// </param>
		/// <param name="ny">
		/// A <see cref="T:System.Double"/>.
		/// </param>
		/// <param name="nz">
		/// A <see cref="T:System.Double"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void NormalStream3ATI(int stream, double nx, double ny, double nz) {
			if      (Delegates.pglNormalStream3dATI != null)
				Delegates.pglNormalStream3dATI(stream, nx, ny, nz);
			else
				throw new InvalidOperationException("binding point NormalStream3ATI cannot be found");
			LogProc("glNormalStream3dATI({0}, {1}, {2}, {3})", stream, nx, ny, nz);
		}

		/// <summary>
		/// Binding for glNormalStream3dvATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Double*"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void NormalStream3ATI(int stream, double[] coords) {
			unsafe {
				fixed (double* fp_coords = coords)
				{
					if      (Delegates.pglNormalStream3dvATI != null)
						Delegates.pglNormalStream3dvATI(stream, fp_coords);
					else
						throw new InvalidOperationException("binding point NormalStream3ATI cannot be found");
				}
			}
			LogProc("glNormalStream3dvATI({0}, {1})", stream, coords);
		}

		/// <summary>
		/// Binding for glNormalStream3dvATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Double"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void NormalStream3ATI(int stream, double* coords) {
			unsafe {
				if      (Delegates.pglNormalStream3dvATI != null)
					Delegates.pglNormalStream3dvATI(stream, coords);
				else
					throw new InvalidOperationException("binding point NormalStream3ATI cannot be found");
			}
			LogProc("glNormalStream3dvATI({0}, {1})", stream, "coords");
		}
		

		/// <summary>
		/// Binding for glNormalStream3fATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="nx">
		/// A <see cref="T:System.Single"/>.
		/// </param>
		/// <param name="ny">
		/// A <see cref="T:System.Single"/>.
		/// </param>
		/// <param name="nz">
		/// A <see cref="T:System.Single"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void NormalStream3ATI(int stream, float nx, float ny, float nz) {
			if      (Delegates.pglNormalStream3fATI != null)
				Delegates.pglNormalStream3fATI(stream, nx, ny, nz);
			else
				throw new InvalidOperationException("binding point NormalStream3ATI cannot be found");
			LogProc("glNormalStream3fATI({0}, {1}, {2}, {3})", stream, nx, ny, nz);
		}

		/// <summary>
		/// Binding for glNormalStream3fvATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Single*"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void NormalStream3ATI(int stream, float[] coords) {
			unsafe {
				fixed (float* fp_coords = coords)
				{
					if      (Delegates.pglNormalStream3fvATI != null)
						Delegates.pglNormalStream3fvATI(stream, fp_coords);
					else
						throw new InvalidOperationException("binding point NormalStream3ATI cannot be found");
				}
			}
			LogProc("glNormalStream3fvATI({0}, {1})", stream, coords);
		}

		/// <summary>
		/// Binding for glNormalStream3fvATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Single"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void NormalStream3ATI(int stream, float* coords) {
			unsafe {
				if      (Delegates.pglNormalStream3fvATI != null)
					Delegates.pglNormalStream3fvATI(stream, coords);
				else
					throw new InvalidOperationException("binding point NormalStream3ATI cannot be found");
			}
			LogProc("glNormalStream3fvATI({0}, {1})", stream, "coords");
		}
		

		/// <summary>
		/// Binding for glNormalStream3iATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="nx">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="ny">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="nz">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void NormalStream3ATI(int stream, int nx, int ny, int nz) {
			if      (Delegates.pglNormalStream3iATI != null)
				Delegates.pglNormalStream3iATI(stream, nx, ny, nz);
			else
				throw new InvalidOperationException("binding point NormalStream3ATI cannot be found");
			LogProc("glNormalStream3iATI({0}, {1}, {2}, {3})", stream, nx, ny, nz);
		}

		/// <summary>
		/// Binding for glNormalStream3ivATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Int32*"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void NormalStream3ATI(int stream, int[] coords) {
			unsafe {
				fixed (int* fp_coords = coords)
				{
					if      (Delegates.pglNormalStream3ivATI != null)
						Delegates.pglNormalStream3ivATI(stream, fp_coords);
					else
						throw new InvalidOperationException("binding point NormalStream3ATI cannot be found");
				}
			}
			LogProc("glNormalStream3ivATI({0}, {1})", stream, coords);
		}

		/// <summary>
		/// Binding for glNormalStream3ivATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void NormalStream3ATI(int stream, int* coords) {
			unsafe {
				if      (Delegates.pglNormalStream3ivATI != null)
					Delegates.pglNormalStream3ivATI(stream, coords);
				else
					throw new InvalidOperationException("binding point NormalStream3ATI cannot be found");
			}
			LogProc("glNormalStream3ivATI({0}, {1})", stream, "coords");
		}
		

		/// <summary>
		/// Binding for glNormalStream3sATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="nx">
		/// A <see cref="T:System.Int16"/>.
		/// </param>
		/// <param name="ny">
		/// A <see cref="T:System.Int16"/>.
		/// </param>
		/// <param name="nz">
		/// A <see cref="T:System.Int16"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void NormalStream3ATI(int stream, Int16 nx, Int16 ny, Int16 nz) {
			if      (Delegates.pglNormalStream3sATI != null)
				Delegates.pglNormalStream3sATI(stream, nx, ny, nz);
			else
				throw new InvalidOperationException("binding point NormalStream3ATI cannot be found");
			LogProc("glNormalStream3sATI({0}, {1}, {2}, {3})", stream, nx, ny, nz);
		}

		/// <summary>
		/// Binding for glNormalStream3svATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Int16*"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void NormalStream3ATI(int stream, Int16[] coords) {
			unsafe {
				fixed (Int16* fp_coords = coords)
				{
					if      (Delegates.pglNormalStream3svATI != null)
						Delegates.pglNormalStream3svATI(stream, fp_coords);
					else
						throw new InvalidOperationException("binding point NormalStream3ATI cannot be found");
				}
			}
			LogProc("glNormalStream3svATI({0}, {1})", stream, coords);
		}

		/// <summary>
		/// Binding for glPassTexCoordATI function.
		/// </summary>
		/// <param name="dst">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="coord">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="swizzle">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void PassTexCoordATI(UInt32 dst, UInt32 coord, int swizzle) {
			if      (Delegates.pglPassTexCoordATI != null)
				Delegates.pglPassTexCoordATI(dst, coord, swizzle);
			else
				throw new InvalidOperationException("binding point PassTexCoordATI cannot be found");
			LogProc("glPassTexCoordATI({0}, {1}, {2})", dst, coord, swizzle);
		}

		/// <summary>
		/// Binding for glPNTrianglesfATI function.
		/// </summary>
		/// <param name="pname">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="param">
		/// A <see cref="T:System.Single"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void PNTrianglesATI(int pname, float param) {
			if      (Delegates.pglPNTrianglesfATI != null)
				Delegates.pglPNTrianglesfATI(pname, param);
			else
				throw new InvalidOperationException("binding point PNTrianglesATI cannot be found");
			LogProc("glPNTrianglesfATI({0}, {1})", pname, param);
		}

		/// <summary>
		/// Binding for glPNTrianglesiATI function.
		/// </summary>
		/// <param name="pname">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="param">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void PNTrianglesATI(int pname, int param) {
			if      (Delegates.pglPNTrianglesiATI != null)
				Delegates.pglPNTrianglesiATI(pname, param);
			else
				throw new InvalidOperationException("binding point PNTrianglesATI cannot be found");
			LogProc("glPNTrianglesiATI({0}, {1})", pname, param);
		}

		/// <summary>
		/// Binding for glSampleMapATI function.
		/// </summary>
		/// <param name="dst">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="interp">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="swizzle">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void SampleMapATI(UInt32 dst, UInt32 interp, int swizzle) {
			if      (Delegates.pglSampleMapATI != null)
				Delegates.pglSampleMapATI(dst, interp, swizzle);
			else
				throw new InvalidOperationException("binding point SampleMapATI cannot be found");
			LogProc("glSampleMapATI({0}, {1}, {2})", dst, interp, swizzle);
		}

		/// <summary>
		/// Binding for glSetFragmentShaderConstantATI function.
		/// </summary>
		/// <param name="dst">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="value">
		/// A <see cref="T:System.Single*"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void SetFragmentShaderConstantATI(UInt32 dst, float[] value) {
			unsafe {
				fixed (float* fp_value = value)
				{
					if      (Delegates.pglSetFragmentShaderConstantATI != null)
						Delegates.pglSetFragmentShaderConstantATI(dst, fp_value);
					else
						throw new InvalidOperationException("binding point SetFragmentShaderConstantATI cannot be found");
				}
			}
			LogProc("glSetFragmentShaderConstantATI({0}, {1})", dst, value);
		}

		/// <summary>
		/// Binding for glSetMultisamplefvAMD function.
		/// </summary>
		/// <param name="pname">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="index">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="val">
		/// A <see cref="T:System.Single*"/>.
		/// </param>
		/// @note This routine is available from OpenGL 3.2
		public static void SetMultisampleAMD(int pname, UInt32 index, float[] val) {
			unsafe {
				fixed (float* fp_val = val)
				{
					if      (Delegates.pglSetMultisamplefvAMD != null)
						Delegates.pglSetMultisamplefvAMD(pname, index, fp_val);
					else
						throw new InvalidOperationException("binding point SetMultisampleAMD cannot be found");
				}
			}
			LogProc("glSetMultisamplefvAMD({0}, {1}, {2})", pname, index, val);
		}

		/// <summary>
		/// Binding for glSetMultisamplefvAMD function.
		/// </summary>
		/// <param name="pname">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="index">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="val">
		/// A <see cref="T:System.Single"/>.
		/// </param>
		/// @note This routine is available from OpenGL 3.2
		public static void SetMultisampleAMD(int pname, UInt32 index, float* val) {
			unsafe {
				if      (Delegates.pglSetMultisamplefvAMD != null)
					Delegates.pglSetMultisamplefvAMD(pname, index, val);
				else
					throw new InvalidOperationException("binding point SetMultisampleAMD cannot be found");
			}
			LogProc("glSetMultisamplefvAMD({0}, {1}, {2})", pname, index, "val");
		}
		

		/// <summary>
		/// Binding for glStencilFuncSeparateATI function.
		/// </summary>
		/// <param name="frontfunc">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="backfunc">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="ref">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="mask">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void StencilFuncSeparateATI(int frontfunc, int backfunc, int @ref, UInt32 mask) {
			if      (Delegates.pglStencilFuncSeparateATI != null)
				Delegates.pglStencilFuncSeparateATI(frontfunc, backfunc, @ref, mask);
			else
				throw new InvalidOperationException("binding point StencilFuncSeparateATI cannot be found");
			LogProc("glStencilFuncSeparateATI({0}, {1}, {2}, {3})", frontfunc, backfunc, @ref, mask);
		}

		/// <summary>
		/// Binding for glStencilOpSeparateATI function.
		/// </summary>
		/// <param name="face">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="sfail">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="dpfail">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="dppass">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void StencilOpSeparateATI(int face, int sfail, int dpfail, int dppass) {
			if      (Delegates.pglStencilOpSeparateATI != null)
				Delegates.pglStencilOpSeparateATI(face, sfail, dpfail, dppass);
			else
				throw new InvalidOperationException("binding point StencilOpSeparateATI cannot be found");
			LogProc("glStencilOpSeparateATI({0}, {1}, {2}, {3})", face, sfail, dpfail, dppass);
		}

		/// <summary>
		/// Binding for glTessellationFactorAMD function.
		/// </summary>
		/// <param name="factor">
		/// A <see cref="T:System.Single"/>.
		/// </param>
		/// @note This routine is available from OpenGL 2.0
		public static void TessellationFactorAMD(float factor) {
			if      (Delegates.pglTessellationFactorAMD != null)
				Delegates.pglTessellationFactorAMD(factor);
			else
				throw new InvalidOperationException("binding point TessellationFactorAMD cannot be found");
			LogProc("glTessellationFactorAMD({0})", factor);
		}

		/// <summary>
		/// Binding for glTessellationModeAMD function.
		/// </summary>
		/// <param name="mode">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 2.0
		public static void TessellationModeAMD(int mode) {
			if      (Delegates.pglTessellationModeAMD != null)
				Delegates.pglTessellationModeAMD(mode);
			else
				throw new InvalidOperationException("binding point TessellationModeAMD cannot be found");
			LogProc("glTessellationModeAMD({0})", mode);
		}

		/// <summary>
		/// Binding for glTexBumpParameterfvATI function.
		/// </summary>
		/// <param name="pname">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="param">
		/// A <see cref="T:System.Single*"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void TexBumpParameterATI(int pname, float[] param) {
			unsafe {
				fixed (float* fp_param = param)
				{
					if      (Delegates.pglTexBumpParameterfvATI != null)
						Delegates.pglTexBumpParameterfvATI(pname, fp_param);
					else
						throw new InvalidOperationException("binding point TexBumpParameterATI cannot be found");
				}
			}
			LogProc("glTexBumpParameterfvATI({0}, {1})", pname, param);
		}

		/// <summary>
		/// Binding for glTexBumpParameterfvATI function.
		/// </summary>
		/// <param name="pname">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="param">
		/// A <see cref="T:System.Single"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void TexBumpParameterATI(int pname, float* param) {
			unsafe {
				if      (Delegates.pglTexBumpParameterfvATI != null)
					Delegates.pglTexBumpParameterfvATI(pname, param);
				else
					throw new InvalidOperationException("binding point TexBumpParameterATI cannot be found");
			}
			LogProc("glTexBumpParameterfvATI({0}, {1})", pname, "param");
		}
		

		/// <summary>
		/// Binding for glTexBumpParameterivATI function.
		/// </summary>
		/// <param name="pname">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="param">
		/// A <see cref="T:System.Int32*"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void TexBumpParameterATI(int pname, int[] param) {
			unsafe {
				fixed (int* fp_param = param)
				{
					if      (Delegates.pglTexBumpParameterivATI != null)
						Delegates.pglTexBumpParameterivATI(pname, fp_param);
					else
						throw new InvalidOperationException("binding point TexBumpParameterATI cannot be found");
				}
			}
			LogProc("glTexBumpParameterivATI({0}, {1})", pname, param);
		}

		/// <summary>
		/// Binding for glTexBumpParameterivATI function.
		/// </summary>
		/// <param name="pname">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="param">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void TexBumpParameterATI(int pname, int* param) {
			unsafe {
				if      (Delegates.pglTexBumpParameterivATI != null)
					Delegates.pglTexBumpParameterivATI(pname, param);
				else
					throw new InvalidOperationException("binding point TexBumpParameterATI cannot be found");
			}
			LogProc("glTexBumpParameterivATI({0}, {1})", pname, "param");
		}
		

		/// <summary>
		/// Binding for glUnmapObjectBufferATI function.
		/// </summary>
		/// <param name="buffer">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void UnmapObjectBufferATI(UInt32 buffer) {
			if      (Delegates.pglUnmapObjectBufferATI != null)
				Delegates.pglUnmapObjectBufferATI(buffer);
			else
				throw new InvalidOperationException("binding point UnmapObjectBufferATI cannot be found");
			LogProc("glUnmapObjectBufferATI({0})", buffer);
		}

		/// <summary>
		/// Binding for glUpdateObjectBufferATI function.
		/// </summary>
		/// <param name="buffer">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="offset">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="size">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="pointer">
		/// A <see cref="T:System.IntPtr"/>.
		/// </param>
		/// <param name="preserve">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void UpdateObjectBufferATI(UInt32 buffer, UInt32 offset, Int32 size, object pointer, int preserve) {
			GCHandle pp_pointer = GCHandle.Alloc(pointer, GCHandleType.Pinned);
			try {
				if      (Delegates.pglUpdateObjectBufferATI != null)
					Delegates.pglUpdateObjectBufferATI(buffer, offset, size, pp_pointer.AddrOfPinnedObject(), preserve);
				else
					throw new InvalidOperationException("binding point UpdateObjectBufferATI cannot be found");
			} finally {
				pp_pointer.Free();
			}
			LogProc("glUpdateObjectBufferATI({0}, {1}, {2}, {3}, {4})", buffer, offset, size, pointer, preserve);
		}

		/// <summary>
		/// Binding for glUpdateObjectBufferATI function.
		/// </summary>
		/// <param name="buffer">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="offset">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="size">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="pointer">
		/// A <see cref="T:System.Void"/>.
		/// </param>
		/// <param name="preserve">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void UpdateObjectBufferATI(UInt32 buffer, UInt32 offset, Int32 size, IntPtr pointer, int preserve) {
			unsafe {
				if      (Delegates.pglUpdateObjectBufferATI != null)
					Delegates.pglUpdateObjectBufferATI(buffer, offset, size, new IntPtr((long)pointer), preserve);
				else
					throw new InvalidOperationException("binding point UpdateObjectBufferATI cannot be found");
			}
			LogProc("glUpdateObjectBufferATI({0}, {1}, {2}, {3}, {4})", buffer, offset, size, "pointer", preserve);
		}
		

		/// <summary>
		/// Binding for glVariantArrayObjectATI function.
		/// </summary>
		/// <param name="id">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="type">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="stride">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="buffer">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="offset">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VariantArrayObjectATI(UInt32 id, int type, Int32 stride, UInt32 buffer, UInt32 offset) {
			if      (Delegates.pglVariantArrayObjectATI != null)
				Delegates.pglVariantArrayObjectATI(id, type, stride, buffer, offset);
			else
				throw new InvalidOperationException("binding point VariantArrayObjectATI cannot be found");
			LogProc("glVariantArrayObjectATI({0}, {1}, {2}, {3}, {4})", id, type, stride, buffer, offset);
		}

		/// <summary>
		/// Binding for glVertexAttribArrayObjectATI function.
		/// </summary>
		/// <param name="index">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="size">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="type">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="normalized">
		/// A <see cref="T:System.Boolean"/>.
		/// </param>
		/// <param name="stride">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="buffer">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// <param name="offset">
		/// A <see cref="T:System.UInt32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexAttribArrayObjectATI(UInt32 index, int size, int type, bool normalized, Int32 stride, UInt32 buffer, UInt32 offset) {
			if      (Delegates.pglVertexAttribArrayObjectATI != null)
				Delegates.pglVertexAttribArrayObjectATI(index, size, type, normalized, stride, buffer, offset);
			else
				throw new InvalidOperationException("binding point VertexAttribArrayObjectATI cannot be found");
			LogProc("glVertexAttribArrayObjectATI({0}, {1}, {2}, {3}, {4}, {5}, {6})", index, size, type, normalized, stride, buffer, offset);
		}

		/// <summary>
		/// Binding for glVertexBlendEnvfATI function.
		/// </summary>
		/// <param name="pname">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="param">
		/// A <see cref="T:System.Single"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexBlendEnvATI(int pname, float param) {
			if      (Delegates.pglVertexBlendEnvfATI != null)
				Delegates.pglVertexBlendEnvfATI(pname, param);
			else
				throw new InvalidOperationException("binding point VertexBlendEnvATI cannot be found");
			LogProc("glVertexBlendEnvfATI({0}, {1})", pname, param);
		}

		/// <summary>
		/// Binding for glVertexBlendEnviATI function.
		/// </summary>
		/// <param name="pname">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="param">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexBlendEnvATI(int pname, int param) {
			if      (Delegates.pglVertexBlendEnviATI != null)
				Delegates.pglVertexBlendEnviATI(pname, param);
			else
				throw new InvalidOperationException("binding point VertexBlendEnvATI cannot be found");
			LogProc("glVertexBlendEnviATI({0}, {1})", pname, param);
		}

		/// <summary>
		/// Binding for glVertexStream1dATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:System.Double"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream1ATI(int stream, double x) {
			if      (Delegates.pglVertexStream1dATI != null)
				Delegates.pglVertexStream1dATI(stream, x);
			else
				throw new InvalidOperationException("binding point VertexStream1ATI cannot be found");
			LogProc("glVertexStream1dATI({0}, {1})", stream, x);
		}

		/// <summary>
		/// Binding for glVertexStream1dvATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Double*"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream1ATI(int stream, double[] coords) {
			unsafe {
				fixed (double* fp_coords = coords)
				{
					if      (Delegates.pglVertexStream1dvATI != null)
						Delegates.pglVertexStream1dvATI(stream, fp_coords);
					else
						throw new InvalidOperationException("binding point VertexStream1ATI cannot be found");
				}
			}
			LogProc("glVertexStream1dvATI({0}, {1})", stream, coords);
		}

		/// <summary>
		/// Binding for glVertexStream1dvATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Double"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream1ATI(int stream, double* coords) {
			unsafe {
				if      (Delegates.pglVertexStream1dvATI != null)
					Delegates.pglVertexStream1dvATI(stream, coords);
				else
					throw new InvalidOperationException("binding point VertexStream1ATI cannot be found");
			}
			LogProc("glVertexStream1dvATI({0}, {1})", stream, "coords");
		}
		

		/// <summary>
		/// Binding for glVertexStream1fATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:System.Single"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream1ATI(int stream, float x) {
			if      (Delegates.pglVertexStream1fATI != null)
				Delegates.pglVertexStream1fATI(stream, x);
			else
				throw new InvalidOperationException("binding point VertexStream1ATI cannot be found");
			LogProc("glVertexStream1fATI({0}, {1})", stream, x);
		}

		/// <summary>
		/// Binding for glVertexStream1fvATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Single*"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream1ATI(int stream, float[] coords) {
			unsafe {
				fixed (float* fp_coords = coords)
				{
					if      (Delegates.pglVertexStream1fvATI != null)
						Delegates.pglVertexStream1fvATI(stream, fp_coords);
					else
						throw new InvalidOperationException("binding point VertexStream1ATI cannot be found");
				}
			}
			LogProc("glVertexStream1fvATI({0}, {1})", stream, coords);
		}

		/// <summary>
		/// Binding for glVertexStream1fvATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Single"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream1ATI(int stream, float* coords) {
			unsafe {
				if      (Delegates.pglVertexStream1fvATI != null)
					Delegates.pglVertexStream1fvATI(stream, coords);
				else
					throw new InvalidOperationException("binding point VertexStream1ATI cannot be found");
			}
			LogProc("glVertexStream1fvATI({0}, {1})", stream, "coords");
		}
		

		/// <summary>
		/// Binding for glVertexStream1iATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream1ATI(int stream, int x) {
			if      (Delegates.pglVertexStream1iATI != null)
				Delegates.pglVertexStream1iATI(stream, x);
			else
				throw new InvalidOperationException("binding point VertexStream1ATI cannot be found");
			LogProc("glVertexStream1iATI({0}, {1})", stream, x);
		}

		/// <summary>
		/// Binding for glVertexStream1ivATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Int32*"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream1ATI(int stream, int[] coords) {
			unsafe {
				fixed (int* fp_coords = coords)
				{
					if      (Delegates.pglVertexStream1ivATI != null)
						Delegates.pglVertexStream1ivATI(stream, fp_coords);
					else
						throw new InvalidOperationException("binding point VertexStream1ATI cannot be found");
				}
			}
			LogProc("glVertexStream1ivATI({0}, {1})", stream, coords);
		}

		/// <summary>
		/// Binding for glVertexStream1ivATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream1ATI(int stream, int* coords) {
			unsafe {
				if      (Delegates.pglVertexStream1ivATI != null)
					Delegates.pglVertexStream1ivATI(stream, coords);
				else
					throw new InvalidOperationException("binding point VertexStream1ATI cannot be found");
			}
			LogProc("glVertexStream1ivATI({0}, {1})", stream, "coords");
		}
		

		/// <summary>
		/// Binding for glVertexStream1sATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:System.Int16"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream1ATI(int stream, Int16 x) {
			if      (Delegates.pglVertexStream1sATI != null)
				Delegates.pglVertexStream1sATI(stream, x);
			else
				throw new InvalidOperationException("binding point VertexStream1ATI cannot be found");
			LogProc("glVertexStream1sATI({0}, {1})", stream, x);
		}

		/// <summary>
		/// Binding for glVertexStream1svATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Int16*"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream1ATI(int stream, Int16[] coords) {
			unsafe {
				fixed (Int16* fp_coords = coords)
				{
					if      (Delegates.pglVertexStream1svATI != null)
						Delegates.pglVertexStream1svATI(stream, fp_coords);
					else
						throw new InvalidOperationException("binding point VertexStream1ATI cannot be found");
				}
			}
			LogProc("glVertexStream1svATI({0}, {1})", stream, coords);
		}

		/// <summary>
		/// Binding for glVertexStream2dATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:System.Double"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:System.Double"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream2ATI(int stream, double x, double y) {
			if      (Delegates.pglVertexStream2dATI != null)
				Delegates.pglVertexStream2dATI(stream, x, y);
			else
				throw new InvalidOperationException("binding point VertexStream2ATI cannot be found");
			LogProc("glVertexStream2dATI({0}, {1}, {2})", stream, x, y);
		}

		/// <summary>
		/// Binding for glVertexStream2dvATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Double*"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream2ATI(int stream, double[] coords) {
			unsafe {
				fixed (double* fp_coords = coords)
				{
					if      (Delegates.pglVertexStream2dvATI != null)
						Delegates.pglVertexStream2dvATI(stream, fp_coords);
					else
						throw new InvalidOperationException("binding point VertexStream2ATI cannot be found");
				}
			}
			LogProc("glVertexStream2dvATI({0}, {1})", stream, coords);
		}

		/// <summary>
		/// Binding for glVertexStream2dvATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Double"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream2ATI(int stream, double* coords) {
			unsafe {
				if      (Delegates.pglVertexStream2dvATI != null)
					Delegates.pglVertexStream2dvATI(stream, coords);
				else
					throw new InvalidOperationException("binding point VertexStream2ATI cannot be found");
			}
			LogProc("glVertexStream2dvATI({0}, {1})", stream, "coords");
		}
		

		/// <summary>
		/// Binding for glVertexStream2fATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:System.Single"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:System.Single"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream2ATI(int stream, float x, float y) {
			if      (Delegates.pglVertexStream2fATI != null)
				Delegates.pglVertexStream2fATI(stream, x, y);
			else
				throw new InvalidOperationException("binding point VertexStream2ATI cannot be found");
			LogProc("glVertexStream2fATI({0}, {1}, {2})", stream, x, y);
		}

		/// <summary>
		/// Binding for glVertexStream2fvATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Single*"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream2ATI(int stream, float[] coords) {
			unsafe {
				fixed (float* fp_coords = coords)
				{
					if      (Delegates.pglVertexStream2fvATI != null)
						Delegates.pglVertexStream2fvATI(stream, fp_coords);
					else
						throw new InvalidOperationException("binding point VertexStream2ATI cannot be found");
				}
			}
			LogProc("glVertexStream2fvATI({0}, {1})", stream, coords);
		}

		/// <summary>
		/// Binding for glVertexStream2fvATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Single"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream2ATI(int stream, float* coords) {
			unsafe {
				if      (Delegates.pglVertexStream2fvATI != null)
					Delegates.pglVertexStream2fvATI(stream, coords);
				else
					throw new InvalidOperationException("binding point VertexStream2ATI cannot be found");
			}
			LogProc("glVertexStream2fvATI({0}, {1})", stream, "coords");
		}
		

		/// <summary>
		/// Binding for glVertexStream2iATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream2ATI(int stream, int x, int y) {
			if      (Delegates.pglVertexStream2iATI != null)
				Delegates.pglVertexStream2iATI(stream, x, y);
			else
				throw new InvalidOperationException("binding point VertexStream2ATI cannot be found");
			LogProc("glVertexStream2iATI({0}, {1}, {2})", stream, x, y);
		}

		/// <summary>
		/// Binding for glVertexStream2ivATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Int32*"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream2ATI(int stream, int[] coords) {
			unsafe {
				fixed (int* fp_coords = coords)
				{
					if      (Delegates.pglVertexStream2ivATI != null)
						Delegates.pglVertexStream2ivATI(stream, fp_coords);
					else
						throw new InvalidOperationException("binding point VertexStream2ATI cannot be found");
				}
			}
			LogProc("glVertexStream2ivATI({0}, {1})", stream, coords);
		}

		/// <summary>
		/// Binding for glVertexStream2ivATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream2ATI(int stream, int* coords) {
			unsafe {
				if      (Delegates.pglVertexStream2ivATI != null)
					Delegates.pglVertexStream2ivATI(stream, coords);
				else
					throw new InvalidOperationException("binding point VertexStream2ATI cannot be found");
			}
			LogProc("glVertexStream2ivATI({0}, {1})", stream, "coords");
		}
		

		/// <summary>
		/// Binding for glVertexStream2sATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:System.Int16"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:System.Int16"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream2ATI(int stream, Int16 x, Int16 y) {
			if      (Delegates.pglVertexStream2sATI != null)
				Delegates.pglVertexStream2sATI(stream, x, y);
			else
				throw new InvalidOperationException("binding point VertexStream2ATI cannot be found");
			LogProc("glVertexStream2sATI({0}, {1}, {2})", stream, x, y);
		}

		/// <summary>
		/// Binding for glVertexStream2svATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Int16*"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream2ATI(int stream, Int16[] coords) {
			unsafe {
				fixed (Int16* fp_coords = coords)
				{
					if      (Delegates.pglVertexStream2svATI != null)
						Delegates.pglVertexStream2svATI(stream, fp_coords);
					else
						throw new InvalidOperationException("binding point VertexStream2ATI cannot be found");
				}
			}
			LogProc("glVertexStream2svATI({0}, {1})", stream, coords);
		}

		/// <summary>
		/// Binding for glVertexStream3dATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:System.Double"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:System.Double"/>.
		/// </param>
		/// <param name="z">
		/// A <see cref="T:System.Double"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream3ATI(int stream, double x, double y, double z) {
			if      (Delegates.pglVertexStream3dATI != null)
				Delegates.pglVertexStream3dATI(stream, x, y, z);
			else
				throw new InvalidOperationException("binding point VertexStream3ATI cannot be found");
			LogProc("glVertexStream3dATI({0}, {1}, {2}, {3})", stream, x, y, z);
		}

		/// <summary>
		/// Binding for glVertexStream3dvATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Double*"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream3ATI(int stream, double[] coords) {
			unsafe {
				fixed (double* fp_coords = coords)
				{
					if      (Delegates.pglVertexStream3dvATI != null)
						Delegates.pglVertexStream3dvATI(stream, fp_coords);
					else
						throw new InvalidOperationException("binding point VertexStream3ATI cannot be found");
				}
			}
			LogProc("glVertexStream3dvATI({0}, {1})", stream, coords);
		}

		/// <summary>
		/// Binding for glVertexStream3dvATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Double"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream3ATI(int stream, double* coords) {
			unsafe {
				if      (Delegates.pglVertexStream3dvATI != null)
					Delegates.pglVertexStream3dvATI(stream, coords);
				else
					throw new InvalidOperationException("binding point VertexStream3ATI cannot be found");
			}
			LogProc("glVertexStream3dvATI({0}, {1})", stream, "coords");
		}
		

		/// <summary>
		/// Binding for glVertexStream3fATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:System.Single"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:System.Single"/>.
		/// </param>
		/// <param name="z">
		/// A <see cref="T:System.Single"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream3ATI(int stream, float x, float y, float z) {
			if      (Delegates.pglVertexStream3fATI != null)
				Delegates.pglVertexStream3fATI(stream, x, y, z);
			else
				throw new InvalidOperationException("binding point VertexStream3ATI cannot be found");
			LogProc("glVertexStream3fATI({0}, {1}, {2}, {3})", stream, x, y, z);
		}

		/// <summary>
		/// Binding for glVertexStream3fvATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Single*"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream3ATI(int stream, float[] coords) {
			unsafe {
				fixed (float* fp_coords = coords)
				{
					if      (Delegates.pglVertexStream3fvATI != null)
						Delegates.pglVertexStream3fvATI(stream, fp_coords);
					else
						throw new InvalidOperationException("binding point VertexStream3ATI cannot be found");
				}
			}
			LogProc("glVertexStream3fvATI({0}, {1})", stream, coords);
		}

		/// <summary>
		/// Binding for glVertexStream3fvATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Single"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream3ATI(int stream, float* coords) {
			unsafe {
				if      (Delegates.pglVertexStream3fvATI != null)
					Delegates.pglVertexStream3fvATI(stream, coords);
				else
					throw new InvalidOperationException("binding point VertexStream3ATI cannot be found");
			}
			LogProc("glVertexStream3fvATI({0}, {1})", stream, "coords");
		}
		

		/// <summary>
		/// Binding for glVertexStream3iATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="z">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream3ATI(int stream, int x, int y, int z) {
			if      (Delegates.pglVertexStream3iATI != null)
				Delegates.pglVertexStream3iATI(stream, x, y, z);
			else
				throw new InvalidOperationException("binding point VertexStream3ATI cannot be found");
			LogProc("glVertexStream3iATI({0}, {1}, {2}, {3})", stream, x, y, z);
		}

		/// <summary>
		/// Binding for glVertexStream3ivATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Int32*"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream3ATI(int stream, int[] coords) {
			unsafe {
				fixed (int* fp_coords = coords)
				{
					if      (Delegates.pglVertexStream3ivATI != null)
						Delegates.pglVertexStream3ivATI(stream, fp_coords);
					else
						throw new InvalidOperationException("binding point VertexStream3ATI cannot be found");
				}
			}
			LogProc("glVertexStream3ivATI({0}, {1})", stream, coords);
		}

		/// <summary>
		/// Binding for glVertexStream3ivATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream3ATI(int stream, int* coords) {
			unsafe {
				if      (Delegates.pglVertexStream3ivATI != null)
					Delegates.pglVertexStream3ivATI(stream, coords);
				else
					throw new InvalidOperationException("binding point VertexStream3ATI cannot be found");
			}
			LogProc("glVertexStream3ivATI({0}, {1})", stream, "coords");
		}
		

		/// <summary>
		/// Binding for glVertexStream3sATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:System.Int16"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:System.Int16"/>.
		/// </param>
		/// <param name="z">
		/// A <see cref="T:System.Int16"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream3ATI(int stream, Int16 x, Int16 y, Int16 z) {
			if      (Delegates.pglVertexStream3sATI != null)
				Delegates.pglVertexStream3sATI(stream, x, y, z);
			else
				throw new InvalidOperationException("binding point VertexStream3ATI cannot be found");
			LogProc("glVertexStream3sATI({0}, {1}, {2}, {3})", stream, x, y, z);
		}

		/// <summary>
		/// Binding for glVertexStream3svATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Int16*"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream3ATI(int stream, Int16[] coords) {
			unsafe {
				fixed (Int16* fp_coords = coords)
				{
					if      (Delegates.pglVertexStream3svATI != null)
						Delegates.pglVertexStream3svATI(stream, fp_coords);
					else
						throw new InvalidOperationException("binding point VertexStream3ATI cannot be found");
				}
			}
			LogProc("glVertexStream3svATI({0}, {1})", stream, coords);
		}

		/// <summary>
		/// Binding for glVertexStream4dATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:System.Double"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:System.Double"/>.
		/// </param>
		/// <param name="z">
		/// A <see cref="T:System.Double"/>.
		/// </param>
		/// <param name="w">
		/// A <see cref="T:System.Double"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream4ATI(int stream, double x, double y, double z, double w) {
			if      (Delegates.pglVertexStream4dATI != null)
				Delegates.pglVertexStream4dATI(stream, x, y, z, w);
			else
				throw new InvalidOperationException("binding point VertexStream4ATI cannot be found");
			LogProc("glVertexStream4dATI({0}, {1}, {2}, {3}, {4})", stream, x, y, z, w);
		}

		/// <summary>
		/// Binding for glVertexStream4dvATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Double*"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream4ATI(int stream, double[] coords) {
			unsafe {
				fixed (double* fp_coords = coords)
				{
					if      (Delegates.pglVertexStream4dvATI != null)
						Delegates.pglVertexStream4dvATI(stream, fp_coords);
					else
						throw new InvalidOperationException("binding point VertexStream4ATI cannot be found");
				}
			}
			LogProc("glVertexStream4dvATI({0}, {1})", stream, coords);
		}

		/// <summary>
		/// Binding for glVertexStream4dvATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Double"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream4ATI(int stream, double* coords) {
			unsafe {
				if      (Delegates.pglVertexStream4dvATI != null)
					Delegates.pglVertexStream4dvATI(stream, coords);
				else
					throw new InvalidOperationException("binding point VertexStream4ATI cannot be found");
			}
			LogProc("glVertexStream4dvATI({0}, {1})", stream, "coords");
		}
		

		/// <summary>
		/// Binding for glVertexStream4fATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:System.Single"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:System.Single"/>.
		/// </param>
		/// <param name="z">
		/// A <see cref="T:System.Single"/>.
		/// </param>
		/// <param name="w">
		/// A <see cref="T:System.Single"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream4ATI(int stream, float x, float y, float z, float w) {
			if      (Delegates.pglVertexStream4fATI != null)
				Delegates.pglVertexStream4fATI(stream, x, y, z, w);
			else
				throw new InvalidOperationException("binding point VertexStream4ATI cannot be found");
			LogProc("glVertexStream4fATI({0}, {1}, {2}, {3}, {4})", stream, x, y, z, w);
		}

		/// <summary>
		/// Binding for glVertexStream4fvATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Single*"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream4ATI(int stream, float[] coords) {
			unsafe {
				fixed (float* fp_coords = coords)
				{
					if      (Delegates.pglVertexStream4fvATI != null)
						Delegates.pglVertexStream4fvATI(stream, fp_coords);
					else
						throw new InvalidOperationException("binding point VertexStream4ATI cannot be found");
				}
			}
			LogProc("glVertexStream4fvATI({0}, {1})", stream, coords);
		}

		/// <summary>
		/// Binding for glVertexStream4fvATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Single"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream4ATI(int stream, float* coords) {
			unsafe {
				if      (Delegates.pglVertexStream4fvATI != null)
					Delegates.pglVertexStream4fvATI(stream, coords);
				else
					throw new InvalidOperationException("binding point VertexStream4ATI cannot be found");
			}
			LogProc("glVertexStream4fvATI({0}, {1})", stream, "coords");
		}
		

		/// <summary>
		/// Binding for glVertexStream4iATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="z">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="w">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream4ATI(int stream, int x, int y, int z, int w) {
			if      (Delegates.pglVertexStream4iATI != null)
				Delegates.pglVertexStream4iATI(stream, x, y, z, w);
			else
				throw new InvalidOperationException("binding point VertexStream4ATI cannot be found");
			LogProc("glVertexStream4iATI({0}, {1}, {2}, {3}, {4})", stream, x, y, z, w);
		}

		/// <summary>
		/// Binding for glVertexStream4ivATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Int32*"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream4ATI(int stream, int[] coords) {
			unsafe {
				fixed (int* fp_coords = coords)
				{
					if      (Delegates.pglVertexStream4ivATI != null)
						Delegates.pglVertexStream4ivATI(stream, fp_coords);
					else
						throw new InvalidOperationException("binding point VertexStream4ATI cannot be found");
				}
			}
			LogProc("glVertexStream4ivATI({0}, {1})", stream, coords);
		}

		/// <summary>
		/// Binding for glVertexStream4ivATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream4ATI(int stream, int* coords) {
			unsafe {
				if      (Delegates.pglVertexStream4ivATI != null)
					Delegates.pglVertexStream4ivATI(stream, coords);
				else
					throw new InvalidOperationException("binding point VertexStream4ATI cannot be found");
			}
			LogProc("glVertexStream4ivATI({0}, {1})", stream, "coords");
		}
		

		/// <summary>
		/// Binding for glVertexStream4sATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:System.Int16"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:System.Int16"/>.
		/// </param>
		/// <param name="z">
		/// A <see cref="T:System.Int16"/>.
		/// </param>
		/// <param name="w">
		/// A <see cref="T:System.Int16"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream4ATI(int stream, Int16 x, Int16 y, Int16 z, Int16 w) {
			if      (Delegates.pglVertexStream4sATI != null)
				Delegates.pglVertexStream4sATI(stream, x, y, z, w);
			else
				throw new InvalidOperationException("binding point VertexStream4ATI cannot be found");
			LogProc("glVertexStream4sATI({0}, {1}, {2}, {3}, {4})", stream, x, y, z, w);
		}

		/// <summary>
		/// Binding for glVertexStream4svATI function.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:System.Int32"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:System.Int16*"/>.
		/// </param>
		/// @note This routine is available from OpenGL 1.2
		public static void VertexStream4ATI(int stream, Int16[] coords) {
			unsafe {
				fixed (Int16* fp_coords = coords)
				{
					if      (Delegates.pglVertexStream4svATI != null)
						Delegates.pglVertexStream4svATI(stream, fp_coords);
					else
						throw new InvalidOperationException("binding point VertexStream4ATI cannot be found");
				}
			}
			LogProc("glVertexStream4svATI({0}, {1})", stream, coords);
		}

		internal static partial class Delegates
		{
			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glAlphaFragmentOp1ATI(int op, UInt32 dst, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod);
			[ThreadStatic]
			internal static glAlphaFragmentOp1ATI pglAlphaFragmentOp1ATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glAlphaFragmentOp2ATI(int op, UInt32 dst, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod, UInt32 arg2, UInt32 arg2Rep, UInt32 arg2Mod);
			[ThreadStatic]
			internal static glAlphaFragmentOp2ATI pglAlphaFragmentOp2ATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glAlphaFragmentOp3ATI(int op, UInt32 dst, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod, UInt32 arg2, UInt32 arg2Rep, UInt32 arg2Mod, UInt32 arg3, UInt32 arg3Rep, UInt32 arg3Mod);
			[ThreadStatic]
			internal static glAlphaFragmentOp3ATI pglAlphaFragmentOp3ATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glArrayObjectATI(int array, int size, int type, Int32 stride, UInt32 buffer, UInt32 offset);
			[ThreadStatic]
			internal static glArrayObjectATI pglArrayObjectATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glBeginFragmentShaderATI();
			[ThreadStatic]
			internal static glBeginFragmentShaderATI pglBeginFragmentShaderATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glBindFragmentShaderATI(UInt32 id);
			[ThreadStatic]
			internal static glBindFragmentShaderATI pglBindFragmentShaderATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glBlendEquationIndexedAMD(UInt32 buf, int mode);
			[ThreadStatic]
			internal static glBlendEquationIndexedAMD pglBlendEquationIndexedAMD = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glBlendEquationSeparateIndexedAMD(UInt32 buf, int modeRGB, int modeAlpha);
			[ThreadStatic]
			internal static glBlendEquationSeparateIndexedAMD pglBlendEquationSeparateIndexedAMD = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glBlendFuncIndexedAMD(UInt32 buf, int src, int dst);
			[ThreadStatic]
			internal static glBlendFuncIndexedAMD pglBlendFuncIndexedAMD = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glBlendFuncSeparateIndexedAMD(UInt32 buf, int srcRGB, int dstRGB, int srcAlpha, int dstAlpha);
			[ThreadStatic]
			internal static glBlendFuncSeparateIndexedAMD pglBlendFuncSeparateIndexedAMD = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glClientActiveVertexStreamATI(int stream);
			[ThreadStatic]
			internal static glClientActiveVertexStreamATI pglClientActiveVertexStreamATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glColorFragmentOp1ATI(int op, UInt32 dst, UInt32 dstMask, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod);
			[ThreadStatic]
			internal static glColorFragmentOp1ATI pglColorFragmentOp1ATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glColorFragmentOp2ATI(int op, UInt32 dst, UInt32 dstMask, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod, UInt32 arg2, UInt32 arg2Rep, UInt32 arg2Mod);
			[ThreadStatic]
			internal static glColorFragmentOp2ATI pglColorFragmentOp2ATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glColorFragmentOp3ATI(int op, UInt32 dst, UInt32 dstMask, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod, UInt32 arg2, UInt32 arg2Rep, UInt32 arg2Mod, UInt32 arg3, UInt32 arg3Rep, UInt32 arg3Mod);
			[ThreadStatic]
			internal static glColorFragmentOp3ATI pglColorFragmentOp3ATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glDeleteFragmentShaderATI(UInt32 id);
			[ThreadStatic]
			internal static glDeleteFragmentShaderATI pglDeleteFragmentShaderATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glDeleteNamesAMD(int identifier, UInt32 num, UInt32* names);
			[ThreadStatic]
			internal static glDeleteNamesAMD pglDeleteNamesAMD = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glDrawBuffersATI(Int32 n, int* bufs);
			[ThreadStatic]
			internal static glDrawBuffersATI pglDrawBuffersATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glDrawElementArrayATI(int mode, Int32 count);
			[ThreadStatic]
			internal static glDrawElementArrayATI pglDrawElementArrayATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glDrawRangeElementArrayATI(int mode, UInt32 start, UInt32 end, Int32 count);
			[ThreadStatic]
			internal static glDrawRangeElementArrayATI pglDrawRangeElementArrayATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glElementPointerATI(int type, IntPtr pointer);
			[ThreadStatic]
			internal static glElementPointerATI pglElementPointerATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glEndFragmentShaderATI();
			[ThreadStatic]
			internal static glEndFragmentShaderATI pglEndFragmentShaderATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glFreeObjectBufferATI(UInt32 buffer);
			[ThreadStatic]
			internal static glFreeObjectBufferATI pglFreeObjectBufferATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate UInt32 glGenFragmentShadersATI(UInt32 range);
			[ThreadStatic]
			internal static glGenFragmentShadersATI pglGenFragmentShadersATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glGenNamesAMD(int identifier, UInt32 num, [Out] UInt32* names);
			[ThreadStatic]
			internal static glGenNamesAMD pglGenNamesAMD = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glGetArrayObjectfvATI(int array, int pname, [Out] float* @params);
			[ThreadStatic]
			internal static glGetArrayObjectfvATI pglGetArrayObjectfvATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glGetArrayObjectivATI(int array, int pname, [Out] int* @params);
			[ThreadStatic]
			internal static glGetArrayObjectivATI pglGetArrayObjectivATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glGetObjectBufferfvATI(UInt32 buffer, int pname, [Out] float* @params);
			[ThreadStatic]
			internal static glGetObjectBufferfvATI pglGetObjectBufferfvATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glGetObjectBufferivATI(UInt32 buffer, int pname, [Out] int* @params);
			[ThreadStatic]
			internal static glGetObjectBufferivATI pglGetObjectBufferivATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glGetTexBumpParameterfvATI(int pname, [Out] float* param);
			[ThreadStatic]
			internal static glGetTexBumpParameterfvATI pglGetTexBumpParameterfvATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glGetTexBumpParameterivATI(int pname, [Out] int* param);
			[ThreadStatic]
			internal static glGetTexBumpParameterivATI pglGetTexBumpParameterivATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glGetVariantArrayObjectfvATI(UInt32 id, int pname, [Out] float* @params);
			[ThreadStatic]
			internal static glGetVariantArrayObjectfvATI pglGetVariantArrayObjectfvATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glGetVariantArrayObjectivATI(UInt32 id, int pname, [Out] int* @params);
			[ThreadStatic]
			internal static glGetVariantArrayObjectivATI pglGetVariantArrayObjectivATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glGetVertexAttribArrayObjectfvATI(UInt32 index, int pname, [Out] float* @params);
			[ThreadStatic]
			internal static glGetVertexAttribArrayObjectfvATI pglGetVertexAttribArrayObjectfvATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glGetVertexAttribArrayObjectivATI(UInt32 index, int pname, [Out] int* @params);
			[ThreadStatic]
			internal static glGetVertexAttribArrayObjectivATI pglGetVertexAttribArrayObjectivATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate bool glIsNameAMD(int identifier, UInt32 name);
			[ThreadStatic]
			internal static glIsNameAMD pglIsNameAMD = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate bool glIsObjectBufferATI(UInt32 buffer);
			[ThreadStatic]
			internal static glIsObjectBufferATI pglIsObjectBufferATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate IntPtr glMapObjectBufferATI(UInt32 buffer);
			[ThreadStatic]
			internal static glMapObjectBufferATI pglMapObjectBufferATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glMultiDrawArraysIndirectAMD(int mode, IntPtr indirect, Int32 primcount, Int32 stride);
			[ThreadStatic]
			internal static glMultiDrawArraysIndirectAMD pglMultiDrawArraysIndirectAMD = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glMultiDrawElementsIndirectAMD(int mode, int type, IntPtr indirect, Int32 primcount, Int32 stride);
			[ThreadStatic]
			internal static glMultiDrawElementsIndirectAMD pglMultiDrawElementsIndirectAMD = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate UInt32 glNewObjectBufferATI(Int32 size, IntPtr pointer, int usage);
			[ThreadStatic]
			internal static glNewObjectBufferATI pglNewObjectBufferATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glNormalStream3bATI(int stream, sbyte nx, sbyte ny, sbyte nz);
			[ThreadStatic]
			internal static glNormalStream3bATI pglNormalStream3bATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glNormalStream3bvATI(int stream, sbyte* coords);
			[ThreadStatic]
			internal static glNormalStream3bvATI pglNormalStream3bvATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glNormalStream3dATI(int stream, double nx, double ny, double nz);
			[ThreadStatic]
			internal static glNormalStream3dATI pglNormalStream3dATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glNormalStream3dvATI(int stream, double* coords);
			[ThreadStatic]
			internal static glNormalStream3dvATI pglNormalStream3dvATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glNormalStream3fATI(int stream, float nx, float ny, float nz);
			[ThreadStatic]
			internal static glNormalStream3fATI pglNormalStream3fATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glNormalStream3fvATI(int stream, float* coords);
			[ThreadStatic]
			internal static glNormalStream3fvATI pglNormalStream3fvATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glNormalStream3iATI(int stream, int nx, int ny, int nz);
			[ThreadStatic]
			internal static glNormalStream3iATI pglNormalStream3iATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glNormalStream3ivATI(int stream, int* coords);
			[ThreadStatic]
			internal static glNormalStream3ivATI pglNormalStream3ivATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glNormalStream3sATI(int stream, Int16 nx, Int16 ny, Int16 nz);
			[ThreadStatic]
			internal static glNormalStream3sATI pglNormalStream3sATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glNormalStream3svATI(int stream, Int16* coords);
			[ThreadStatic]
			internal static glNormalStream3svATI pglNormalStream3svATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glPassTexCoordATI(UInt32 dst, UInt32 coord, int swizzle);
			[ThreadStatic]
			internal static glPassTexCoordATI pglPassTexCoordATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glPNTrianglesfATI(int pname, float param);
			[ThreadStatic]
			internal static glPNTrianglesfATI pglPNTrianglesfATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glPNTrianglesiATI(int pname, int param);
			[ThreadStatic]
			internal static glPNTrianglesiATI pglPNTrianglesiATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glSampleMapATI(UInt32 dst, UInt32 interp, int swizzle);
			[ThreadStatic]
			internal static glSampleMapATI pglSampleMapATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glSetFragmentShaderConstantATI(UInt32 dst, float* value);
			[ThreadStatic]
			internal static glSetFragmentShaderConstantATI pglSetFragmentShaderConstantATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glSetMultisamplefvAMD(int pname, UInt32 index, float* val);
			[ThreadStatic]
			internal static glSetMultisamplefvAMD pglSetMultisamplefvAMD = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glStencilFuncSeparateATI(int frontfunc, int backfunc, int @ref, UInt32 mask);
			[ThreadStatic]
			internal static glStencilFuncSeparateATI pglStencilFuncSeparateATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glStencilOpSeparateATI(int face, int sfail, int dpfail, int dppass);
			[ThreadStatic]
			internal static glStencilOpSeparateATI pglStencilOpSeparateATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glTessellationFactorAMD(float factor);
			[ThreadStatic]
			internal static glTessellationFactorAMD pglTessellationFactorAMD = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glTessellationModeAMD(int mode);
			[ThreadStatic]
			internal static glTessellationModeAMD pglTessellationModeAMD = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glTexBumpParameterfvATI(int pname, float* param);
			[ThreadStatic]
			internal static glTexBumpParameterfvATI pglTexBumpParameterfvATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glTexBumpParameterivATI(int pname, int* param);
			[ThreadStatic]
			internal static glTexBumpParameterivATI pglTexBumpParameterivATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glUnmapObjectBufferATI(UInt32 buffer);
			[ThreadStatic]
			internal static glUnmapObjectBufferATI pglUnmapObjectBufferATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glUpdateObjectBufferATI(UInt32 buffer, UInt32 offset, Int32 size, IntPtr pointer, int preserve);
			[ThreadStatic]
			internal static glUpdateObjectBufferATI pglUpdateObjectBufferATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glVariantArrayObjectATI(UInt32 id, int type, Int32 stride, UInt32 buffer, UInt32 offset);
			[ThreadStatic]
			internal static glVariantArrayObjectATI pglVariantArrayObjectATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glVertexAttribArrayObjectATI(UInt32 index, int size, int type, bool normalized, Int32 stride, UInt32 buffer, UInt32 offset);
			[ThreadStatic]
			internal static glVertexAttribArrayObjectATI pglVertexAttribArrayObjectATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glVertexBlendEnvfATI(int pname, float param);
			[ThreadStatic]
			internal static glVertexBlendEnvfATI pglVertexBlendEnvfATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glVertexBlendEnviATI(int pname, int param);
			[ThreadStatic]
			internal static glVertexBlendEnviATI pglVertexBlendEnviATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glVertexStream1dATI(int stream, double x);
			[ThreadStatic]
			internal static glVertexStream1dATI pglVertexStream1dATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glVertexStream1dvATI(int stream, double* coords);
			[ThreadStatic]
			internal static glVertexStream1dvATI pglVertexStream1dvATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glVertexStream1fATI(int stream, float x);
			[ThreadStatic]
			internal static glVertexStream1fATI pglVertexStream1fATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glVertexStream1fvATI(int stream, float* coords);
			[ThreadStatic]
			internal static glVertexStream1fvATI pglVertexStream1fvATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glVertexStream1iATI(int stream, int x);
			[ThreadStatic]
			internal static glVertexStream1iATI pglVertexStream1iATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glVertexStream1ivATI(int stream, int* coords);
			[ThreadStatic]
			internal static glVertexStream1ivATI pglVertexStream1ivATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glVertexStream1sATI(int stream, Int16 x);
			[ThreadStatic]
			internal static glVertexStream1sATI pglVertexStream1sATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glVertexStream1svATI(int stream, Int16* coords);
			[ThreadStatic]
			internal static glVertexStream1svATI pglVertexStream1svATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glVertexStream2dATI(int stream, double x, double y);
			[ThreadStatic]
			internal static glVertexStream2dATI pglVertexStream2dATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glVertexStream2dvATI(int stream, double* coords);
			[ThreadStatic]
			internal static glVertexStream2dvATI pglVertexStream2dvATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glVertexStream2fATI(int stream, float x, float y);
			[ThreadStatic]
			internal static glVertexStream2fATI pglVertexStream2fATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glVertexStream2fvATI(int stream, float* coords);
			[ThreadStatic]
			internal static glVertexStream2fvATI pglVertexStream2fvATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glVertexStream2iATI(int stream, int x, int y);
			[ThreadStatic]
			internal static glVertexStream2iATI pglVertexStream2iATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glVertexStream2ivATI(int stream, int* coords);
			[ThreadStatic]
			internal static glVertexStream2ivATI pglVertexStream2ivATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glVertexStream2sATI(int stream, Int16 x, Int16 y);
			[ThreadStatic]
			internal static glVertexStream2sATI pglVertexStream2sATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glVertexStream2svATI(int stream, Int16* coords);
			[ThreadStatic]
			internal static glVertexStream2svATI pglVertexStream2svATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glVertexStream3dATI(int stream, double x, double y, double z);
			[ThreadStatic]
			internal static glVertexStream3dATI pglVertexStream3dATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glVertexStream3dvATI(int stream, double* coords);
			[ThreadStatic]
			internal static glVertexStream3dvATI pglVertexStream3dvATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glVertexStream3fATI(int stream, float x, float y, float z);
			[ThreadStatic]
			internal static glVertexStream3fATI pglVertexStream3fATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glVertexStream3fvATI(int stream, float* coords);
			[ThreadStatic]
			internal static glVertexStream3fvATI pglVertexStream3fvATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glVertexStream3iATI(int stream, int x, int y, int z);
			[ThreadStatic]
			internal static glVertexStream3iATI pglVertexStream3iATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glVertexStream3ivATI(int stream, int* coords);
			[ThreadStatic]
			internal static glVertexStream3ivATI pglVertexStream3ivATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glVertexStream3sATI(int stream, Int16 x, Int16 y, Int16 z);
			[ThreadStatic]
			internal static glVertexStream3sATI pglVertexStream3sATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glVertexStream3svATI(int stream, Int16* coords);
			[ThreadStatic]
			internal static glVertexStream3svATI pglVertexStream3svATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glVertexStream4dATI(int stream, double x, double y, double z, double w);
			[ThreadStatic]
			internal static glVertexStream4dATI pglVertexStream4dATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glVertexStream4dvATI(int stream, double* coords);
			[ThreadStatic]
			internal static glVertexStream4dvATI pglVertexStream4dvATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glVertexStream4fATI(int stream, float x, float y, float z, float w);
			[ThreadStatic]
			internal static glVertexStream4fATI pglVertexStream4fATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glVertexStream4fvATI(int stream, float* coords);
			[ThreadStatic]
			internal static glVertexStream4fvATI pglVertexStream4fvATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glVertexStream4iATI(int stream, int x, int y, int z, int w);
			[ThreadStatic]
			internal static glVertexStream4iATI pglVertexStream4iATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glVertexStream4ivATI(int stream, int* coords);
			[ThreadStatic]
			internal static glVertexStream4ivATI pglVertexStream4ivATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal delegate void glVertexStream4sATI(int stream, Int16 x, Int16 y, Int16 z, Int16 w);
			[ThreadStatic]
			internal static glVertexStream4sATI pglVertexStream4sATI = null;

			[System.Security.SuppressUnmanagedCodeSecurity()]
			internal unsafe delegate void glVertexStream4svATI(int stream, Int16* coords);
			[ThreadStatic]
			internal static glVertexStream4svATI pglVertexStream4svATI = null;

		}

		internal static partial class Imports
		{
			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glAlphaFragmentOp1ATI", ExactSpelling = true)]
			internal extern static void glAlphaFragmentOp1ATI(int op, UInt32 dst, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glAlphaFragmentOp2ATI", ExactSpelling = true)]
			internal extern static void glAlphaFragmentOp2ATI(int op, UInt32 dst, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod, UInt32 arg2, UInt32 arg2Rep, UInt32 arg2Mod);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glAlphaFragmentOp3ATI", ExactSpelling = true)]
			internal extern static void glAlphaFragmentOp3ATI(int op, UInt32 dst, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod, UInt32 arg2, UInt32 arg2Rep, UInt32 arg2Mod, UInt32 arg3, UInt32 arg3Rep, UInt32 arg3Mod);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glArrayObjectATI", ExactSpelling = true)]
			internal extern static void glArrayObjectATI(int array, int size, int type, Int32 stride, UInt32 buffer, UInt32 offset);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glBeginFragmentShaderATI", ExactSpelling = true)]
			internal extern static void glBeginFragmentShaderATI();

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glBindFragmentShaderATI", ExactSpelling = true)]
			internal extern static void glBindFragmentShaderATI(UInt32 id);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glBlendEquationIndexedAMD", ExactSpelling = true)]
			internal extern static void glBlendEquationIndexedAMD(UInt32 buf, int mode);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glBlendEquationSeparateIndexedAMD", ExactSpelling = true)]
			internal extern static void glBlendEquationSeparateIndexedAMD(UInt32 buf, int modeRGB, int modeAlpha);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glBlendFuncIndexedAMD", ExactSpelling = true)]
			internal extern static void glBlendFuncIndexedAMD(UInt32 buf, int src, int dst);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glBlendFuncSeparateIndexedAMD", ExactSpelling = true)]
			internal extern static void glBlendFuncSeparateIndexedAMD(UInt32 buf, int srcRGB, int dstRGB, int srcAlpha, int dstAlpha);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glClientActiveVertexStreamATI", ExactSpelling = true)]
			internal extern static void glClientActiveVertexStreamATI(int stream);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glColorFragmentOp1ATI", ExactSpelling = true)]
			internal extern static void glColorFragmentOp1ATI(int op, UInt32 dst, UInt32 dstMask, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glColorFragmentOp2ATI", ExactSpelling = true)]
			internal extern static void glColorFragmentOp2ATI(int op, UInt32 dst, UInt32 dstMask, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod, UInt32 arg2, UInt32 arg2Rep, UInt32 arg2Mod);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glColorFragmentOp3ATI", ExactSpelling = true)]
			internal extern static void glColorFragmentOp3ATI(int op, UInt32 dst, UInt32 dstMask, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod, UInt32 arg2, UInt32 arg2Rep, UInt32 arg2Mod, UInt32 arg3, UInt32 arg3Rep, UInt32 arg3Mod);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glDeleteFragmentShaderATI", ExactSpelling = true)]
			internal extern static void glDeleteFragmentShaderATI(UInt32 id);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glDeleteNamesAMD", ExactSpelling = true)]
			internal extern static unsafe void glDeleteNamesAMD(int identifier, UInt32 num, UInt32* names);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glDrawBuffersATI", ExactSpelling = true)]
			internal extern static unsafe void glDrawBuffersATI(Int32 n, int* bufs);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glDrawElementArrayATI", ExactSpelling = true)]
			internal extern static void glDrawElementArrayATI(int mode, Int32 count);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glDrawRangeElementArrayATI", ExactSpelling = true)]
			internal extern static void glDrawRangeElementArrayATI(int mode, UInt32 start, UInt32 end, Int32 count);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glElementPointerATI", ExactSpelling = true)]
			internal extern static void glElementPointerATI(int type, IntPtr pointer);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glEndFragmentShaderATI", ExactSpelling = true)]
			internal extern static void glEndFragmentShaderATI();

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glFreeObjectBufferATI", ExactSpelling = true)]
			internal extern static void glFreeObjectBufferATI(UInt32 buffer);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glGenFragmentShadersATI", ExactSpelling = true)]
			internal extern static UInt32 glGenFragmentShadersATI(UInt32 range);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glGenNamesAMD", ExactSpelling = true)]
			internal extern static unsafe void glGenNamesAMD(int identifier, UInt32 num, [Out]UInt32* names);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glGetArrayObjectfvATI", ExactSpelling = true)]
			internal extern static unsafe void glGetArrayObjectfvATI(int array, int pname, [Out]float @params);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glGetArrayObjectivATI", ExactSpelling = true)]
			internal extern static unsafe void glGetArrayObjectivATI(int array, int pname, [Out]int @params);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glGetObjectBufferfvATI", ExactSpelling = true)]
			internal extern static unsafe void glGetObjectBufferfvATI(UInt32 buffer, int pname, [Out]float @params);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glGetObjectBufferivATI", ExactSpelling = true)]
			internal extern static unsafe void glGetObjectBufferivATI(UInt32 buffer, int pname, [Out]int @params);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glGetTexBumpParameterfvATI", ExactSpelling = true)]
			internal extern static unsafe void glGetTexBumpParameterfvATI(int pname, [Out]float* param);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glGetTexBumpParameterivATI", ExactSpelling = true)]
			internal extern static unsafe void glGetTexBumpParameterivATI(int pname, [Out]int* param);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glGetVariantArrayObjectfvATI", ExactSpelling = true)]
			internal extern static unsafe void glGetVariantArrayObjectfvATI(UInt32 id, int pname, [Out]float @params);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glGetVariantArrayObjectivATI", ExactSpelling = true)]
			internal extern static unsafe void glGetVariantArrayObjectivATI(UInt32 id, int pname, [Out]int @params);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glGetVertexAttribArrayObjectfvATI", ExactSpelling = true)]
			internal extern static unsafe void glGetVertexAttribArrayObjectfvATI(UInt32 index, int pname, [Out]float* @params);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glGetVertexAttribArrayObjectivATI", ExactSpelling = true)]
			internal extern static unsafe void glGetVertexAttribArrayObjectivATI(UInt32 index, int pname, [Out]int* @params);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glIsNameAMD", ExactSpelling = true)]
			internal extern static bool glIsNameAMD(int identifier, UInt32 name);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glIsObjectBufferATI", ExactSpelling = true)]
			internal extern static bool glIsObjectBufferATI(UInt32 buffer);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glMapObjectBufferATI", ExactSpelling = true)]
			internal extern static IntPtr glMapObjectBufferATI(UInt32 buffer);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glMultiDrawArraysIndirectAMD", ExactSpelling = true)]
			internal extern static void glMultiDrawArraysIndirectAMD(int mode, IntPtr indirect, Int32 primcount, Int32 stride);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glMultiDrawElementsIndirectAMD", ExactSpelling = true)]
			internal extern static void glMultiDrawElementsIndirectAMD(int mode, int type, IntPtr indirect, Int32 primcount, Int32 stride);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glNewObjectBufferATI", ExactSpelling = true)]
			internal extern static UInt32 glNewObjectBufferATI(Int32 size, IntPtr pointer, int usage);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glNormalStream3bATI", ExactSpelling = true)]
			internal extern static void glNormalStream3bATI(int stream, sbyte nx, sbyte ny, sbyte nz);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glNormalStream3bvATI", ExactSpelling = true)]
			internal extern static unsafe void glNormalStream3bvATI(int stream, sbyte* coords);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glNormalStream3dATI", ExactSpelling = true)]
			internal extern static void glNormalStream3dATI(int stream, double nx, double ny, double nz);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glNormalStream3dvATI", ExactSpelling = true)]
			internal extern static unsafe void glNormalStream3dvATI(int stream, double* coords);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glNormalStream3fATI", ExactSpelling = true)]
			internal extern static void glNormalStream3fATI(int stream, float nx, float ny, float nz);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glNormalStream3fvATI", ExactSpelling = true)]
			internal extern static unsafe void glNormalStream3fvATI(int stream, float* coords);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glNormalStream3iATI", ExactSpelling = true)]
			internal extern static void glNormalStream3iATI(int stream, int nx, int ny, int nz);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glNormalStream3ivATI", ExactSpelling = true)]
			internal extern static unsafe void glNormalStream3ivATI(int stream, int* coords);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glNormalStream3sATI", ExactSpelling = true)]
			internal extern static void glNormalStream3sATI(int stream, Int16 nx, Int16 ny, Int16 nz);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glNormalStream3svATI", ExactSpelling = true)]
			internal extern static unsafe void glNormalStream3svATI(int stream, Int16* coords);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glPassTexCoordATI", ExactSpelling = true)]
			internal extern static void glPassTexCoordATI(UInt32 dst, UInt32 coord, int swizzle);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glPNTrianglesfATI", ExactSpelling = true)]
			internal extern static void glPNTrianglesfATI(int pname, float param);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glPNTrianglesiATI", ExactSpelling = true)]
			internal extern static void glPNTrianglesiATI(int pname, int param);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glSampleMapATI", ExactSpelling = true)]
			internal extern static void glSampleMapATI(UInt32 dst, UInt32 interp, int swizzle);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glSetFragmentShaderConstantATI", ExactSpelling = true)]
			internal extern static unsafe void glSetFragmentShaderConstantATI(UInt32 dst, float* value);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glSetMultisamplefvAMD", ExactSpelling = true)]
			internal extern static unsafe void glSetMultisamplefvAMD(int pname, UInt32 index, float* val);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glStencilFuncSeparateATI", ExactSpelling = true)]
			internal extern static void glStencilFuncSeparateATI(int frontfunc, int backfunc, int @ref, UInt32 mask);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glStencilOpSeparateATI", ExactSpelling = true)]
			internal extern static void glStencilOpSeparateATI(int face, int sfail, int dpfail, int dppass);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glTessellationFactorAMD", ExactSpelling = true)]
			internal extern static void glTessellationFactorAMD(float factor);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glTessellationModeAMD", ExactSpelling = true)]
			internal extern static void glTessellationModeAMD(int mode);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glTexBumpParameterfvATI", ExactSpelling = true)]
			internal extern static unsafe void glTexBumpParameterfvATI(int pname, float* param);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glTexBumpParameterivATI", ExactSpelling = true)]
			internal extern static unsafe void glTexBumpParameterivATI(int pname, int* param);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glUnmapObjectBufferATI", ExactSpelling = true)]
			internal extern static void glUnmapObjectBufferATI(UInt32 buffer);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glUpdateObjectBufferATI", ExactSpelling = true)]
			internal extern static void glUpdateObjectBufferATI(UInt32 buffer, UInt32 offset, Int32 size, IntPtr pointer, int preserve);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVariantArrayObjectATI", ExactSpelling = true)]
			internal extern static void glVariantArrayObjectATI(UInt32 id, int type, Int32 stride, UInt32 buffer, UInt32 offset);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexAttribArrayObjectATI", ExactSpelling = true)]
			internal extern static void glVertexAttribArrayObjectATI(UInt32 index, int size, int type, bool normalized, Int32 stride, UInt32 buffer, UInt32 offset);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexBlendEnvfATI", ExactSpelling = true)]
			internal extern static void glVertexBlendEnvfATI(int pname, float param);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexBlendEnviATI", ExactSpelling = true)]
			internal extern static void glVertexBlendEnviATI(int pname, int param);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream1dATI", ExactSpelling = true)]
			internal extern static void glVertexStream1dATI(int stream, double x);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream1dvATI", ExactSpelling = true)]
			internal extern static unsafe void glVertexStream1dvATI(int stream, double* coords);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream1fATI", ExactSpelling = true)]
			internal extern static void glVertexStream1fATI(int stream, float x);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream1fvATI", ExactSpelling = true)]
			internal extern static unsafe void glVertexStream1fvATI(int stream, float* coords);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream1iATI", ExactSpelling = true)]
			internal extern static void glVertexStream1iATI(int stream, int x);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream1ivATI", ExactSpelling = true)]
			internal extern static unsafe void glVertexStream1ivATI(int stream, int* coords);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream1sATI", ExactSpelling = true)]
			internal extern static void glVertexStream1sATI(int stream, Int16 x);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream1svATI", ExactSpelling = true)]
			internal extern static unsafe void glVertexStream1svATI(int stream, Int16* coords);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream2dATI", ExactSpelling = true)]
			internal extern static void glVertexStream2dATI(int stream, double x, double y);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream2dvATI", ExactSpelling = true)]
			internal extern static unsafe void glVertexStream2dvATI(int stream, double* coords);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream2fATI", ExactSpelling = true)]
			internal extern static void glVertexStream2fATI(int stream, float x, float y);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream2fvATI", ExactSpelling = true)]
			internal extern static unsafe void glVertexStream2fvATI(int stream, float* coords);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream2iATI", ExactSpelling = true)]
			internal extern static void glVertexStream2iATI(int stream, int x, int y);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream2ivATI", ExactSpelling = true)]
			internal extern static unsafe void glVertexStream2ivATI(int stream, int* coords);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream2sATI", ExactSpelling = true)]
			internal extern static void glVertexStream2sATI(int stream, Int16 x, Int16 y);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream2svATI", ExactSpelling = true)]
			internal extern static unsafe void glVertexStream2svATI(int stream, Int16* coords);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream3dATI", ExactSpelling = true)]
			internal extern static void glVertexStream3dATI(int stream, double x, double y, double z);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream3dvATI", ExactSpelling = true)]
			internal extern static unsafe void glVertexStream3dvATI(int stream, double* coords);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream3fATI", ExactSpelling = true)]
			internal extern static void glVertexStream3fATI(int stream, float x, float y, float z);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream3fvATI", ExactSpelling = true)]
			internal extern static unsafe void glVertexStream3fvATI(int stream, float* coords);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream3iATI", ExactSpelling = true)]
			internal extern static void glVertexStream3iATI(int stream, int x, int y, int z);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream3ivATI", ExactSpelling = true)]
			internal extern static unsafe void glVertexStream3ivATI(int stream, int* coords);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream3sATI", ExactSpelling = true)]
			internal extern static void glVertexStream3sATI(int stream, Int16 x, Int16 y, Int16 z);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream3svATI", ExactSpelling = true)]
			internal extern static unsafe void glVertexStream3svATI(int stream, Int16* coords);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream4dATI", ExactSpelling = true)]
			internal extern static void glVertexStream4dATI(int stream, double x, double y, double z, double w);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream4dvATI", ExactSpelling = true)]
			internal extern static unsafe void glVertexStream4dvATI(int stream, double* coords);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream4fATI", ExactSpelling = true)]
			internal extern static void glVertexStream4fATI(int stream, float x, float y, float z, float w);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream4fvATI", ExactSpelling = true)]
			internal extern static unsafe void glVertexStream4fvATI(int stream, float* coords);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream4iATI", ExactSpelling = true)]
			internal extern static void glVertexStream4iATI(int stream, int x, int y, int z, int w);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream4ivATI", ExactSpelling = true)]
			internal extern static unsafe void glVertexStream4ivATI(int stream, int* coords);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream4sATI", ExactSpelling = true)]
			internal extern static void glVertexStream4sATI(int stream, Int16 x, Int16 y, Int16 z, Int16 w);

			[System.Security.SuppressUnmanagedCodeSecurity()]
			[System.Runtime.InteropServices.DllImport(Library, EntryPoint = "glVertexStream4svATI", ExactSpelling = true)]
			internal extern static unsafe void glVertexStream4svATI(int stream, Int16* coords);

		}

	}
}
